six-degrees 0.3.0 → 0.4.0

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

@@ -0,0 +1,113 @@
+// Who you reached through a circle, and whether their own circle is next.
+//
+// Blake, 2026-09-25: "i would like to sigingy if a orb in the 2nd degree is
+// added already so it shows they are ready for a 2nd degree scan to get the 3rd
+// degree so it needs to be intuitive with the orb glowing".
+//
+// "Ready" is one rule, kept here once. It used to live in three slightly
+// different copies (Outlink's new doors, the profile page's mapping bar and the
+// Degrees panel's Auto-Bridge Next), and only one of them knew about hidden
+// lists. Someone is ready for a circle scan when all of these are true:
+//   - they're your connection now (degree 1);
+//   - they came to you through a circle: unlocked_from_bridge_id, which
+//     lib/promote.js keeps when it clears source_connection_id, and which a
+//     request sent from the app sets to the circle you asked through;
+//   - their own circle hasn't been scanned: nobody in it is saved, and the
+//     scanner has no note of reading it (bridge-progress.json);
+//   - their list isn't known to be hidden (bridge-skips.json).
+// A glow that fired on hidden lists would teach you to ignore it, so a hidden
+// list is its own state, never "ready".
+//
+// Plain functions, no React; tests/reach.test.mjs.
+
+import { keyFor, compareBridges } from './separation.js';
+
+/**
+ * What the rules read, built once per load.
+ *
+ * @param connections 1st-degree rows
+ * @param degree2     2nd-degree rows: whose circle each sits in
+ * @param notes       what the scanner noted, from /api/scraper?reach=1:
+ *                    { skips: [{ profileUrl }] (hidden lists), read: [profileUrl] (lists it has read) }
+ * @returns {{ scanned: Set, read: Set, hidden: Set, reachedFrom: Map }}
+ *   `reachedFrom` is circle id → the connections you reached through it.
+ */
+export function reachIndex(connections = [], degree2 = [], notes = {}) {
+  const scanned = new Set();
+  for (const row of degree2 || []) {
+    if (row?.source_connection_id != null) scanned.add(row.source_connection_id);
+  }
+  const hidden = new Set();
+  for (const s of notes?.skips || []) {
+    if (s?.profileUrl) hidden.add(keyFor({ profile_url: s.profileUrl }));
+  }
+  const read = new Set();
+  for (const url of notes?.read || []) {
+    if (url) read.add(keyFor({ profile_url: url }));
+  }
+  const reachedFrom = new Map();
+  for (const row of connections || []) {
+    const from = row?.unlocked_from_bridge_id;
+    if (from == null || row.degree !== 1) continue;
+    let list = reachedFrom.get(from);
+    if (!list) reachedFrom.set(from, (list = []));
+    list.push(row);
+  }
+  return { scanned, read, hidden, reachedFrom };
+}
+
+/**
+ * Their own circle: 'scanned' (someone in it is saved, or the scanner read
+ * their list and everyone on it was already yours), 'hidden' (they keep their
+ * connections private) or 'todo'.
+ */
+export function circleState(person, reach) {
+  if (!person) return 'todo';
+  if (reach.scanned.has(person.id)) return 'scanned';
+  if (person.profile_url && reach.read?.has(keyFor(person))) return 'scanned';
+  if (person.profile_url && reach.hidden.has(keyFor(person))) return 'hidden';
+  return 'todo';
+}
+
+/**
+ * For someone you reached through a circle: 'ready' (their circle can be
+ * scanned next), 'hidden' or 'scanned'. Null for anyone else: people who were
+ * always your connections, and 2nd-degree rows (a request sent from the app
+ * marks those with the circle it asked through, but they aren't yours yet).
+ */
+export function reachState(person, reach) {
+  if (!person || person.degree !== 1 || person.unlocked_from_bridge_id == null) return null;
+  const state = circleState(person, reach);
+  return state === 'todo' ? 'ready' : state;
+}
+
+/** Everyone ready for a circle scan, strongest first. */
+export function readyToScan(connections, reach) {
+  return (connections || []).filter((c) => reachState(c, reach) === 'ready').sort(compareBridges);
+}
+
+/** How many people you reached through each circle are ready, by circle id. */
+export function readyByCircle(reach) {
+  const out = new Map();
+  for (const [from, people] of reach.reachedFrom) {
+    const n = people.filter((p) => reachState(p, reach) === 'ready').length;
+    if (n) out.set(from, n);
+  }
+  return out;
+}
+
+/**
+ * What scanning one circle asks of LinkedIn: one profile view to find their
+ * list, then a search for every page of it, `pages` at most (LinkedIn shows
+ * 100). About 0.55 minutes a page with the scanner's rests (20 s before each
+ * page, a minute more after every 10), so about 55 minutes for a whole list.
+ * The Scan page and the Degrees panel both say it from here.
+ */
+export function circleScanCost(pages = 100) {
+  const searches = Math.max(1, Math.min(100, Math.round(pages) || 100));
+  return {
+    profileViews: 1,
+    searches,
+    minutes: searches >= 100 ? 55 : Math.max(5, Math.round(searches * 0.55)),
+  };
+}

package/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/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();
 }
 

package/lib/scan-state.js

@@ -40,6 +40,7 @@ export function runningNow(job) {
     case 'install': return 'The scanner\'s packages are being installed';
     case 'setup': return 'The scanner is being set up';
     case 'login': return 'The LinkedIn sign-in window is open';
+    case 'photos': return 'Profile photos are being saved';
     default: return 'A scan is running';
   }
 }

package/lib/scanner-setup.js

@@ -1,5 +1,6 @@
 // What the Scan page's first step says and offers, from the checks GET
-// /api/scraper reports (app/api/scraper/route.js, lib/scanner-python.js).
+// /api/scraper reports (app/api/scraper/route.js, lib/scanner-python.js), and
+// whether it asks for your field before that (askForField).
 // Plain data in, plain data out: the page draws it, and
 // tests/scanner-setup.test.mjs checks every state without a browser. No Node
 // imports here; the page runs in the browser.
@@ -102,3 +103,21 @@ function stepOnly(status) {
     button: null,
   };
 }
+
+/**
+ * Whether the Scan page asks for your field first (app/components/FieldStep.js):
+ * once, before the first scan. Never to someone who already has a network, has
+ * picked a sector (Scores → Your sector), or answered or skipped the question
+ * before (`fieldAsked`). `status` is GET /api/scraper's answer (null while it
+ * loads), `settings` GET /api/settings' `settings` (undefined while it loads,
+ * null when it couldn't be read). null means not known yet: the page waits,
+ * rather than show the steps and then swap them for the question.
+ */
+export function askForField(status, settings) {
+  if (!status) return null;
+  const n = status.network;
+  // No counts means the app couldn't be asked; a scan running is past asking.
+  if (!n || n.first || n.second || n.third || status.running) return false;
+  if (settings === undefined) return null;
+  return Boolean(settings && !settings.fieldAsked && !settings.sectorFocus?.sectors?.length);
+}

package/lib/score-guess.js

@@ -0,0 +1,60 @@
+// Whether someone's power score is a guess, and why (Blake, 2026-09-28: "suggest
+// scanning their cluster if their profile card is opened"). A score rests on
+// a title and a company; when the headline gives the app neither to read, the
+// score is the middle of the scale, not a judgment. The card says so and
+// offers what would firm it up: their circle, which the bridge boost reads
+// (lib/scoring.js bridgeBoost, up to +2).
+
+import { scorePerson, companyScore } from './scoring.js';
+
+// A company score someone set: yours (Paths → Scores) or the sample network's.
+// score_why says so ("Northwind (7/10, your score)"); a sector lean on a
+// company the app doesn't know ("6/10: 5 + 1 your sector") is still a guess.
+const SET_BY_HAND = /\/10, (your|sample) score\)/;
+// A stored working: "Director / Head (7.5) · Northwind Labs (6/10)", with
+// "Former " or "Student · " before the title, and the company's score as
+// "(7/10, your score)" or "(6/10: 5 + 1 your sector: Dental)".
+const WHY = /^(?:Former )?(?:Student · )?(.+?) \([\d.]+\) · (no company found|.+?) \(\d+(?:\.\d+)?\/10(?:[:,][^)]*)?\)/;
+
+/**
+ * Why a row's score is a guess, or null when it rests on a title and a
+ * company the app can read.
+ *   title    the headline names no title the rules read: "Title unclear", or
+ *            only a company ("Works there")
+ *   company  no company found, or one the built-in lists don't know and
+ *            nobody scored
+ *   never    never scored
+ * An audience of their own ("2.5M followers") is a title, and needs no company.
+ * @returns {{ title: boolean, company: boolean, never: boolean, companyName: string|null, reason: string } | null}
+ */
+export function scoreGuess(row) {
+  if (!row) return null;
+  if (row.power_score == null || row.power_score === '' || !row.tier) {
+    return { title: false, company: false, never: true, companyName: null, reason: 'They haven’t been scored yet.' };
+  }
+  // The role the stored score was built on, from its working (score_why, which
+  // lib/scoring.js explainScore writes): scoring again here would use none of
+  // the network's headcounts, your company scores or your sector, and could
+  // pick a different role of someone with several.
+  const m = String(row.score_why || '').match(WHY);
+  let label, name, company;
+  if (m) {
+    label = m[1];
+    name = m[2] === 'no company found' ? null : m[2];
+    company = !name || (!SET_BY_HAND.test(row.score_why) && !['known', 'data'].includes(companyScore(name).source));
+  } else {
+    const s = scorePerson(row);
+    label = s.title.label;
+    name = s.company || null;
+    company = ['none', 'default', 'network'].includes(s.companySource);
+  }
+  const audience = label.startsWith('Audience of');
+  const title = label === 'Title unclear' || label.includes('Works there');
+  if (audience) company = false;
+  if (!title && !company) return null;
+  let reason;
+  if (title && company) reason = name ? `Their headline doesn’t say their title, and the app doesn’t know ${name}.` : 'Their headline names no title or company the app can read.';
+  else if (title) reason = 'Their headline doesn’t say their title.';
+  else reason = name ? `The app doesn’t know ${name}, so it counts as the middle of the scale.` : 'The app couldn’t find where they work.';
+  return { title, company, never: false, companyName: name, reason };
+}