six-degrees 0.3.0 → 0.4.0-beta.1

package/.next/standalone/lib/circle.js

@@ -0,0 +1,169 @@
+// Someone's circle as rings, for the top of their profile card.
+//
+// Blake, 2026-09-28: "for every profile card we can see their network circle
+// … all of their current connections scraped and graded but then outside of
+// that sits the connections all from d2 that we added and scanned coming from
+// that person as the provider of the cluster … and then for d3,d4,d5,d6".
+//
+// Two facts the app already keeps make the whole chain, with nothing new stored:
+//   source_connection_id     whose circle a row sits in: a scan of that person found it
+//   unlocked_from_bridge_id  who introduced someone you connected with, kept
+//                            after they became your connection (lib/promote.js)
+// So from a person P: P's circle (D2, through P) → the people in it you
+// connected with or asked → their circles (D3) → who you added from those →
+// their circles (D4) … to six degrees. Everyone appears once, in the nearest
+// ring they reach.
+
+import { keyFor, score1 } from './separation.js';
+
+export const MAX_DEGREE = 6;
+
+/** A request is out to them and they haven't accepted (Sidebar's "Connect to Unlock Path"). */
+export const requestedByDefault = (row) => row?.unlock_status === 'pending';
+
+/**
+ * Rows grouped two ways: `circles`, id → the rows a scan of that person found;
+ * `introduced`, id → your connections you met through them.
+ */
+export function circleIndex(connections = [], degree2 = []) {
+  const circles = new Map();
+  for (const row of degree2 || []) {
+    const id = row?.source_connection_id;
+    if (id == null) continue;
+    let list = circles.get(id);
+    if (!list) circles.set(id, (list = []));
+    list.push(row);
+  }
+  const introduced = new Map();
+  for (const row of connections || []) {
+    const id = row?.unlocked_from_bridge_id;
+    if (id == null || row.degree !== 1) continue;
+    let list = introduced.get(id);
+    if (!list) introduced.set(id, (list = []));
+    list.push(row);
+  }
+  return { circles, introduced };
+}
+
+const STATE_ORDER = { connected: 0, requested: 1 };
+const byStateThenPower = (a, b) => (STATE_ORDER[a.state] ?? 2) - (STATE_ORDER[b.state] ?? 2)
+  || score1(b.row) - score1(a.row)
+  || String(a.row.name || '').localeCompare(String(b.row.name || ''));
+
+/**
+ * The rings around `person`: [{ degree, people: [{ row, key, parentId, state }] }],
+ * degree 2 first. `state` is 'connected' (you added them, so their own circle
+ * is the next ring out), 'requested' (a request is out: drawn dotted) or null.
+ * Also the totals: { people, connected, requested }.
+ */
+export function circleRings(person, index, { maxDegree = MAX_DEGREE, isRequested = requestedByDefault } = {}) {
+  const rings = [];
+  const totals = { people: 0, connected: 0, requested: 0 };
+  if (!person || !index) return { rings, totals };
+  const seen = new Set([keyFor(person)]);
+  let frontier = [person];
+  for (let degree = 2; degree <= maxDegree && frontier.length; degree++) {
+    const ring = [];
+    const next = [];
+    for (const parent of frontier) {
+      const kids = [];
+      // The people you connected with first: they have circles of their own.
+      for (const row of index.introduced.get(parent.id) || []) {
+        const key = keyFor(row);
+        if (seen.has(key)) continue;
+        seen.add(key);
+        kids.push({ row, key, parentId: parent.id, state: 'connected' });
+        next.push(row);
+      }
+      for (const row of index.circles.get(parent.id) || []) {
+        const key = keyFor(row);
+        if (seen.has(key)) continue;
+        seen.add(key);
+        kids.push({ row, key, parentId: parent.id, state: isRequested(row) ? 'requested' : null });
+      }
+      kids.sort(byStateThenPower);
+      ring.push(...kids);
+    }
+    if (!ring.length) break;
+    for (const p of ring) {
+      totals.people++;
+      if (p.state === 'connected') totals.connected++;
+      else if (p.state === 'requested') totals.requested++;
+    }
+    rings.push({ degree, people: ring });
+    frontier = next;
+  }
+  return { rings, totals };
+}
+
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+
+/**
+ * Where every dot goes, in a square `size` wide: a radial tree. Each person
+ * gets a slice of the circle in proportion to how much of the next rings
+ * hangs off them, so whoever opened the most reach shows it at a glance, and
+ * their circle fans out behind them.
+ * Returns { size, center, rings: [{ degree, radius, dotR, items }], spokes }.
+ */
+export function circleLayout(rings = [], size = 240) {
+  const half = size / 2;
+  const R = rings.length;
+  const radiusOf = (k) => half * (R === 1 ? 0.78 : 0.4 + 0.52 * (k / (R - 1)));
+
+  // Each ring's people by who they hang off, in the ring's order.
+  const byParent = rings.map((ring) => {
+    const m = new Map();
+    for (const p of ring.people) {
+      if (!m.has(p.parentId)) m.set(p.parentId, []);
+      m.get(p.parentId).push(p);
+    }
+    return m;
+  });
+  const kidsOf = (k, id) => byParent[k + 1]?.get(id) || [];
+
+  // Weights, outermost ring first: at least 1, else what hangs off them.
+  const weight = new Map();
+  for (let k = R - 1; k >= 0; k--) {
+    for (const p of rings[k].people) {
+      const w = p.state === 'connected' ? kidsOf(k, p.row.id).reduce((s, c) => s + weight.get(c), 0) : 0;
+      weight.set(p, Math.max(1, w));
+    }
+  }
+
+  const out = [];
+  const spokes = [];
+  const span = new Map();   // row id → [start, end] angle for its children
+  const START = -Math.PI / 2;
+  for (let k = 0; k < R; k++) {
+    const radius = radiusOf(k);
+    const people = rings[k].people;
+    const dotR = clamp((2 * Math.PI * radius) / Math.max(1, people.length) * 0.32, 0.8, size / 60);
+    const items = [];
+    for (const [parentId, group] of byParent[k]) {
+      const [a0, a1] = k === 0 ? [START, START + 2 * Math.PI] : span.get(parentId) || [START, START + 2 * Math.PI];
+      const total = group.reduce((s, p) => s + weight.get(p), 0);
+      let a = a0;
+      for (const p of group) {
+        const w = ((a1 - a0) * weight.get(p)) / total;
+        const angle = a + w / 2;
+        const x = half + radius * Math.cos(angle);
+        const y = half + radius * Math.sin(angle);
+        items.push({ ...p, angle, x, y });
+        if (p.state === 'connected') span.set(p.row.id, [a, a + w]);
+        a += w;
+      }
+    }
+    // A line from each person you added out to the middle of their own circle.
+    if (k + 1 < R) {
+      const nextR = radiusOf(k + 1);
+      for (const it of items) {
+        if (it.state !== 'connected' || !kidsOf(k, it.row.id).length) continue;
+        const [s, e] = span.get(it.row.id);
+        const mid = (s + e) / 2;
+        spokes.push({ x1: it.x, y1: it.y, x2: half + nextR * Math.cos(mid), y2: half + nextR * Math.sin(mid) });
+      }
+    }
+    out.push({ degree: rings[k].degree, radius, dotR, items });
+  }
+  return { size, center: { x: half, y: half }, rings: out, spokes };
+}

package/.next/standalone/lib/companies.js

@@ -85,7 +85,7 @@ export const isSenior = (headline) => getSeniority(headline).level >= 4;
  * A company's industry is the one scoring uses (lib/scoring.js
  * networkCompanies over the same rows): the curated list's, else the name's,
  * else what most of its people say. So a company's colour here is the sector
- * Settings → Your sector leans on, and each company is the one scoring
+ * Scores → Your sector leans on, and each company is the one scoring
  * scores: both name it with cleanCompany().
  */
 export function buildCompanyIndex(rows = []) {

package/.next/standalone/lib/csv.js

@@ -1,4 +1,4 @@
-import { scorePerson } from './scoring.js';
+import { scorePerson, curveCutoffs, curvedTier } from './scoring.js';
 // LinkedIn Connections.csv import — parsed ENTIRELY in the browser.
 //
 // Nothing is uploaded and nothing is written to the database: an imported
@@ -49,6 +49,20 @@ export function scoreRecord(headline, company) {
   return { seniority_score: s.title.points, company_prestige_score: s.companyScore, power_score: s.power, tier: s.tier };
 }
 
+/**
+ * Tiers for a whole import, graded on its own curve (lib/scoring.js CURVE):
+ * a CSV import uses the app's defaults, never your settings (no company
+ * scores, no sector), and the curve is the default, so the first look at any
+ * export has a top. Scores → Tiers says so while one is open. Run on the
+ * parse (the import page's counts) and on every load (the tab keeps only
+ * what the export says, packConnections), so the two always agree.
+ */
+function gradeOnCurve(connections) {
+  const cut = curveCutoffs(connections.map((c) => c.power_score));
+  for (const c of connections) c.tier = curvedTier(c.power_score, cut);
+  return connections;
+}
+
 // Stable id from the profile URL so re-importing keeps node identity.
 function hashId(input) {
   let h = 5381;
@@ -138,7 +152,7 @@ export function parseConnectionsCsv(text) {
     );
   }
 
-  connections.sort((a, b) => b.power_score - a.power_score);
+  gradeOnCurve(connections).sort((a, b) => b.power_score - a.power_score);
   return { connections, skipped, total: connections.length + skipped };
 }
 
@@ -161,8 +175,7 @@ export function packConnections(connections) {
 }
 
 export function unpackConnections(rows = []) {
-  return rows
-    .map(([id, name, role, company, profileUrl, connected_date]) => connectionFrom({ id, name, role, company, profileUrl, connected_date }))
+  return gradeOnCurve(rows.map(([id, name, role, company, profileUrl, connected_date]) => connectionFrom({ id, name, role, company, profileUrl, connected_date })))
     .sort((a, b) => b.power_score - a.power_score);
 }
 

package/.next/standalone/lib/db-client.js

@@ -108,6 +108,7 @@ export function applySchema(db) {
 // exists, so columns added after first release are added here, once.
 const ADDED_COLUMNS = [
   ['linkedin_connections', 'score_why', 'TEXT'],
+  ['linkedin_connections', 'mutual_count', 'INTEGER'],
 ];
 
 function addMissingColumns(db) {

package/.next/standalone/lib/ingest.js

@@ -100,3 +100,15 @@ export function refreshNotifications({ added = [], checked = 0, tierOf = () => n
   }
   return out;
 }
+
+/**
+ * LinkedIn's own count of the mutual connections you share with someone, as
+ * the scanner read it off their result card (scripts/scrape.py
+ * BRIDGE_RESULTS_JS), or null. A whole number from 1 (the bridge is always
+ * one) to 30,000 (LinkedIn's cap on connections); anything else is a misread
+ * and is dropped, never stored.
+ */
+export function mutualCountOf(value) {
+  const n = typeof value === 'string' && /^\d[\d,]*$/.test(value.trim()) ? Number(value.replace(/,/g, '')) : value;
+  return Number.isInteger(n) && n >= 1 && n <= 30000 ? n : null;
+}

package/.next/standalone/lib/legacy-offer.js

@@ -1,4 +1,4 @@
-// Paths → Scores: the one-time offer to keep the curated list's old scores as
+// The Scores tab: the one-time offer to keep the curated list's old scores as
 // your own, after the list was made neutral (lib/legacy-scores.js has the old
 // scores and why each changed).
 //
@@ -10,7 +10,7 @@
 // scored on the server, so the page doesn't ask while one is open.
 //
 // Keeping writes the old score under every name scoring uses for the entry's
-// companies, as Paths → Scores sets a score (setCompanyScores), then rescores
+// companies, as the Scores tab sets a score (setCompanyScores), then rescores
 // everyone once for the whole batch. Keep or No thanks, it is never offered
 // again, and an offer whose first look finds nothing to offer closes itself.
 
@@ -62,14 +62,14 @@ export function legacyOfferState(db = getDb()) {
 }
 
 /**
- * What Paths → Scores offers, or null: nothing when the offer isn't open
+ * What the Scores tab offers, or null: nothing when the offer isn't open
  * (never was, or was answered) or no company in the network lost an old score
  * that you haven't replaced with one of your own. That last closes it for
  * good ('none'): the network the old list scored is the one read here, so
- * nothing could turn up later, and every visit to Paths → Scores would
+ * nothing could turn up later, and every visit to the Scores tab would
  * otherwise read the whole network again to find nothing.
  *
- * The companies are the ones Paths → Scores lists, those someone works at now,
+ * The companies are the ones the Scores tab lists, those someone works at now,
  * so a kept score shows there as yours and Auto can hand it back. (A name only
  * in former roles would be a score nothing lists; its people's former role
  * counts at 70% and moves them little.) Each is compared by its built-in score
@@ -116,7 +116,8 @@ export function legacyOffer(db = getDb()) {
       name: o.name,
       was: o.was,
       now: main.now.score,
-      estimated: main.now.source !== 'known',
+      // A score from the curated list or the public dataset is a fact, not an estimate.
+      estimated: !['known', 'data'].includes(main.now.source),
       people: o.people.size,
       names: o.names.map((n) => n.name).sort(),
     };

package/.next/standalone/lib/legacy-scores.js

@@ -1,5 +1,5 @@
 // The curated company list's scores from before it was made neutral, kept for
-// one thing only: the one-time offer on Paths → Scores to keep them as your
+// one thing only: the one-time offer on the Scores tab to keep them as your
 // own (lib/legacy-offer.js). Nothing scores with these. lib/scoring.js never
 // imports this file, and the model must never read it.
 //
@@ -24,7 +24,7 @@
 
 export const LEGACY_SCORES = [
   // Rescored: scored like its peers Pinterest, Reddit and X.
-  ['Snap', 9, /^(snap|snapchat)( inc)?$/, 'media'],
+  ['Snap', 9, /^(snap|snapchat)( inc)?( (specs|spectacles|(mena|emea|apac|latam|north america)( region)?))?$/, 'media'],
   // Removed: private companies that are neither household names nor Fortune
   // 500-sized, and small startups.
   ['Anduril', 9, /^anduril( industries)?$/, 'defense'],

package/.next/standalone/lib/rarity.js

@@ -0,0 +1,80 @@
+// How rare the way in to someone is: a distinction, never a score.
+//
+// Blake, 2026-09-28: "if i have like 20 or 30 mututals with someone … they are
+// most likely to add me but that means they are not that hard to reach … no
+// mutuals at all besides the person im adding from then they must be a rarer
+// connection". Mutual connections say how much your world and theirs overlap.
+// Many means they'll probably accept; few means the path to them is rare and
+// the bridge who knows them is worth more. Neither says anything about who they
+// are, so rarity never enters the power score or the tier. It is shown and
+// filtered beside them: "S and only one way in" is a rare find, "S and warm"
+// an easy win.
+//
+// The count is LinkedIn's own mutual count where a scan saved one
+// (mutual_count), else the ways in the app has seen: how many of your scanned
+// connections know them. That second one is only a floor. With 14 of 150
+// circles scanned, a "1" may really be 20, and it can only go up as you scan
+// more, so everything that shows it says where it came from.
+
+export const RARITY = [
+  { key: 'only', label: 'Only way in', range: '1', max: 1, color: '#00E5FF' },
+  { key: 'rare', label: 'Rare', range: '2–3', max: 3, color: '#4FC3F7' },
+  { key: 'uncommon', label: 'Uncommon', range: '4–10', max: 10, color: '#B0BEC5' },
+  { key: 'common', label: 'Common', range: '11–30', max: 30, color: '#FFB74D' },
+  { key: 'warm', label: 'Warm', range: '31+', max: Infinity, color: '#FF7043' },
+];
+
+const BY_KEY = new Map(RARITY.map((r) => [r.key, r]));
+
+/** The band for a number of mutual connections (the bridge counts: at least 1). */
+export function rarityFor(count) {
+  const n = Math.max(1, Math.floor(Number(count) || 1));
+  return RARITY.find((r) => n <= r.max).key;
+}
+
+export function rarityInfo(key) {
+  return BY_KEY.get(key) ?? null;
+}
+
+/**
+ * How many mutual connections you share with someone, and where that number
+ * came from: { count, from: 'linkedin' | 'scans' }. `waysIn` is how many of
+ * your scanned connections know them (lib/separation.js).
+ */
+export function mutualsOf(row, waysIn = 1) {
+  const saved = Number(row?.mutual_count);
+  if (Number.isFinite(saved) && saved >= 1) return { count: Math.floor(saved), from: 'linkedin' };
+  return { count: Math.max(1, Math.floor(Number(waysIn) || 1)), from: 'scans' };
+}
+
+/** Someone's rarity: { key, count, from }. */
+export function rarityOf(row, waysIn = 1) {
+  const m = mutualsOf(row, waysIn);
+  return { key: rarityFor(m.count), ...m };
+}
+
+/**
+ * Does a person pass both filters? Each filter is a Set of what's switched on;
+ * an empty set lets everyone through. Tier and rarity must BOTH match, so
+ * "S" + "Only way in" is exactly the rare finds.
+ */
+export function passes({ tier, rarity }, { tiers = new Set(), rarities = new Set() } = {}) {
+  if (tiers.size && !tiers.has(tier)) return false;
+  if (rarities.size && !(rarity && rarities.has(rarity))) return false;
+  return true;
+}
+
+/** People per band, for the chips' counts. `items` carry `rarity` (a key). */
+export function countByRarity(items = []) {
+  const out = Object.fromEntries(RARITY.map((r) => [r.key, 0]));
+  for (const it of items) if (it?.rarity && out[it.rarity] !== undefined) out[it.rarity]++;
+  return out;
+}
+
+/** Turn one key on or off in a filter set, as a new Set (React state). */
+export function toggle(set, key) {
+  const next = new Set(set);
+  if (next.has(key)) next.delete(key);
+  else next.add(key);
+  return next;
+}

package/.next/standalone/lib/requests-client.js

@@ -0,0 +1,113 @@
+// A request you've sent, everywhere at once.
+//
+// Blake, 2026-09-28: "once a person is sent our a connection request hitting
+// that button then it should commuiniacte in the app all around". It didn't.
+// Each place that sent one kept its own note of it: the card's link told
+// nothing else on the page (and kept offering itself), the Outlink queue kept
+// a list of row ids, and Separation, the circle and Orbit read nothing at all,
+// even after a reload. Now there is one list, per person (their profile URL,
+// so every bridge's copy of them agrees), loaded once and changed only through
+// markRequested / undoRequest here, and every view reads it (useRequests).
+
+import { keyFor } from './separation.js';
+
+export const REQUESTS_UNKNOWN = Object.freeze({ known: false, sent: new Set(), mine: new Map(), version: 0 });
+
+const listeners = new Set();
+let now = REQUESTS_UNKNOWN;
+let loading = null;
+// What this page did itself, person → true (sent) / false (undone). It wins
+// over the list as loaded, so a send made while the list was on its way stays.
+const mine = new Map();
+
+function publish(sent = now.sent, known = now.known) {
+  now = Object.freeze({ known, sent, mine: new Map(mine), version: now.version + 1 });
+  for (const listener of [...listeners]) listener();
+}
+
+function load() {
+  if (loading || now.known) return loading;
+  loading = fetch('/api/outreach')
+    .then((r) => (r.ok ? r.json() : null))
+    .then((d) => { if (d) publish(new Set((d.pending || []).map(keyFor)), true); })
+    .catch(() => { /* the sample network, or the app restarting: the rows' own columns stand in */ })
+    .finally(() => { loading = null; });
+  return loading;
+}
+
+/** Call `listener` whenever the list changes. Returns the way to stop. */
+export function watchRequests(listener) {
+  listeners.add(listener);
+  load();
+  return () => listeners.delete(listener);
+}
+
+export function requestsNow() {
+  return now;
+}
+
+/**
+ * Is a request out to this person? What this page did wins; then the list
+ * as loaded; until that arrives, the row's own columns.
+ */
+export function hasRequest(row, state = now) {
+  if (!row) return false;
+  const key = keyFor(row);
+  if (state.mine.has(key)) return state.mine.get(key);
+  if (state.known) return state.sent.has(key);
+  return row.unlock_status === 'pending' || row.outreach_status === 'sent';
+}
+
+/** How many people have a request out. */
+export function requestCount(state = now) {
+  const keys = new Set(state.known ? state.sent : []);
+  for (const [key, on] of state.mine) (on ? keys.add(key) : keys.delete(key));
+  return keys.size;
+}
+
+async function post(body) {
+  const r = await fetch('/api/outreach', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  const d = await r.json().catch(() => ({}));
+  if (!r.ok) throw new Error(d.error || 'Could not save that.');
+  return d;
+}
+
+/**
+ * You sent this person a request. Every view shows it at once; the save
+ * follows, and is taken back on screen if it fails. `bridgeId` is the
+ * connection you asked through, kept for when they accept.
+ */
+export async function markRequested(row, { bridgeId } = {}) {
+  const key = keyFor(row);
+  const before = mine.has(key) ? mine.get(key) : undefined;
+  mine.set(key, true);
+  publish();
+  try {
+    return await post({ action: 'mark-sent', connectionId: row.id, profileUrl: row.profile_url, bridgeId });
+  } catch (err) {
+    if (before === undefined) mine.delete(key);
+    else mine.set(key, before);
+    publish();
+    throw err;
+  }
+}
+
+/** Take a request back, everywhere. */
+export async function undoRequest(row) {
+  const key = keyFor(row);
+  const before = mine.has(key) ? mine.get(key) : undefined;
+  mine.set(key, false);
+  publish();
+  try {
+    return await post({ action: 'undo', connectionId: row.id, profileUrl: row.profile_url });
+  } catch (err) {
+    if (before === undefined) mine.delete(key);
+    else mine.set(key, before);
+    publish();
+    throw err;
+  }
+}

package/.next/standalone/lib/rpc.js

@@ -6,7 +6,7 @@ import { getDb, newId, nowIso } from './db-client.js';
 // results back. rpc('score_new_connections') is that procedure's name, kept
 // for the routes that call it; it rescores with lib/scoring.js like the rest.
 
-import { readNetwork, scoreNetwork, explainScore, SCORING_VERSION, KNOWN_COMPANIES, RULE_TABLES } from './scoring.js';
+import { readNetwork, scoreNetwork, explainScore, SCORING_VERSION, KNOWN_COMPANIES, COMPANY_DATA, RULE_TABLES, TIER_SCALE_SETTING } from './scoring.js';
 import { industryKeyOf, INDUSTRIES } from './companies.js';
 import { readSettings } from './settings.js';
 import { SECTOR_FOCUS_SETTING, focusFingerprint, previewSectorFocus } from './sector-focus.js';
@@ -14,7 +14,8 @@ import { LEGACY_OFFER_KEY } from './legacy-scores.js';
 import { sectorMatcher, sectorGroup, sectorLabel } from './sector-directory.js';
 
 // The word lists and rules the stored scores were computed with: a fingerprint
-// of every entry on the curated company list (name, score, alias, industry),
+// of every entry on the curated company list and the public dataset (name,
+// score, alias, industry),
 // of the broad industries' words and labels (lib/companies.js INDUSTRIES), and
 // of every rule table scoring reads headlines and names with (lib/scoring.js
 // RULE_TABLES: titles, students and clubs, what isn't a company, the reach
@@ -26,12 +27,14 @@ import { sectorMatcher, sectorGroup, sectorLabel } from './sector-directory.js';
 // does, with no number to remember to bump. Copies from before the list was
 // made neutral stamped none, which is also how rescoreAll() knows to offer
 // keeping their old scores (lib/legacy-offer.js).
-export function scoringStamp({ known = KNOWN_COMPANIES, industries = INDUSTRIES, rules = RULE_TABLES } = {}) {
+export function scoringStamp({ known = KNOWN_COMPANIES, data = COMPANY_DATA, industries = INDUSTRIES, rules = RULE_TABLES } = {}) {
   // JSON has no patterns or sets: a pattern counts by its source and flags, a set by its members.
   const plain = (key, value) => (value instanceof RegExp ? String(value) : value instanceof Set ? [...value] : value);
   return createHash('sha256')
     .update(JSON.stringify([
       known.map(([name, score, alias, industry]) => [name, score, String(alias), industry]),
+      // The public dataset too: an entry added or rescored rescores stored scores.
+      data.map(([name, score, alias, industry]) => [name, score, String(alias), industry]),
       industries.map(({ key, label, words }) => [key, label, String(words)]),
       rules,
     ], plain))
@@ -45,7 +48,7 @@ export function companyOverrides(db = getDb()) {
 }
 
 /**
- * Set company scores as your own ([[name, score], …]), the way Paths → Scores
+ * Set company scores as your own ([[name, score], …]), the way the Scores tab
  * does: one row per name, replacing any you had. Rescoring is the caller's
  * job, so a batch rescores once.
  */
@@ -61,6 +64,11 @@ export function sectorFocusOf(db = getDb()) {
   return readSettings(db, { sectorFocus: SECTOR_FOCUS_SETTING }).sectorFocus;
 }
 
+/** Scores → Tiers: 'curve' (graded on your network's curve, the default) or 'fixed'. */
+export function tierScaleOf(db = getDb()) {
+  return readSettings(db, { tierScale: TIER_SCALE_SETTING }).tierScale;
+}
+
 /**
  * What rescoring reads: every row, as scoring needs it. `withPeople` adds each
  * row's name, for naming who a change would move.
@@ -74,7 +82,7 @@ export function scoringRows(db = getDb(), { withPeople = false } = {}) {
  * Every headline read once, the way scoring reads it: each company's
  * headcount, its one industry, the sector directory's sectors it matches and
  * the industries those sit under. Rescoring, Settings' preview and
- * suggestions, and Paths → Scores all read the rows through this, so they
+ * suggestions, and the Scores tab all read the rows through this, so they
  * agree on which company is in which sector.
  */
 export function readForScoring(rows) {
@@ -85,9 +93,9 @@ export function readForScoring(rows) {
  * Rescore everyone. The score depends on the whole network (how many of your
  * people work at a company, how strong a bridge's circle is), so after any
  * ingest or company-score change every row is recomputed — ~0.1s for 4,000.
- * Your company scores and your sector focus are read here, not passed in, so
- * every path that rescores (an import, a company score, Settings, a stale
- * model) applies both.
+ * Your company scores, your sector focus and how tiers are graded are read
+ * here, not passed in, so every path that rescores (an import, a company
+ * score, Settings, a stale model) applies them all.
  *
  * `compareWith` is another sector focus: Settings' save passes the one it
  * replaced. The same rows are then also scored with it, in memory, and the
@@ -102,12 +110,13 @@ export function rescoreAll({ compareWith } = {}) {
   const rows = scoringRows(db);
   const overrides = companyOverrides(db);
   const focus = sectorFocusOf(db);
+  const tierScale = tierScaleOf(db);
   // Every headline is read once, however many ways the rows are then scored.
   const read = readForScoring(rows);
-  const { scores } = scoreNetwork(rows, { overrides, focus, read });
+  const { scores } = scoreNetwork(rows, { overrides, focus, tierScale, read });
   // Worked out before anything is written, so a failure leaves nothing half done.
   const change = compareWith === undefined ? null
-    : previewSectorFocus(rows, { overrides, read, from: compareWith, to: focus, examples: 0 });
+    : previewSectorFocus(rows, { overrides, read, from: compareWith, to: focus, tierScale, examples: 0 });
   const update = db.prepare(`UPDATE linkedin_connections SET seniority_score = ?, company_prestige_score = ?, power_score = ?, tier = ?,
     score_why = ?, circle_power = ?, circle_s_count = ?, circle_a_count = ?, circle_elite_pct = ?, is_catalyst = ?, catalyst_score = ?, updated_at = ?
     WHERE id = ?`);
@@ -131,9 +140,10 @@ export function rescoreAll({ compareWith } = {}) {
     }
     const meta = db.prepare('INSERT INTO app_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value');
     meta.run('scoring_version', String(SCORING_VERSION));
-    // Which curated list and sector focus these scores were computed with (see rescoreIfStale).
+    // Which curated list, sector focus and tier scale these scores were computed with (see rescoreIfStale).
     meta.run('scoring_list', KNOWN_LIST_STAMP);
     meta.run('scoring_focus', focusFingerprint(focus));
+    meta.run('scoring_tiers', tierScale);
     db.exec('COMMIT');
   } catch (err) {
     db.exec('ROLLBACK');
@@ -144,16 +154,17 @@ export function rescoreAll({ compareWith } = {}) {
 
 /**
  * Rescore once if the stored scores came from an older scoring model or
- * curated list, or from a sector focus other than the one saved now: an
- * update, a database restored or brought from another computer, or a Settings
- * save whose rescore never finished.
+ * curated list, or from a sector focus or tier scale other than the one saved
+ * now: an update, a database restored or brought from another computer, or a
+ * Settings save whose rescore never finished.
  */
 export function rescoreIfStale() {
   const db = getDb();
   const meta = (key) => db.prepare('SELECT value FROM app_meta WHERE key = ?').get(key)?.value;
   const fresh = meta('scoring_version') === String(SCORING_VERSION)
     && meta('scoring_list') === KNOWN_LIST_STAMP
-    && meta('scoring_focus') === focusFingerprint(sectorFocusOf(db));
+    && meta('scoring_focus') === focusFingerprint(sectorFocusOf(db))
+    && meta('scoring_tiers') === tierScaleOf(db);
   return fresh ? { scored: 0 } : rescoreAll();
 }