six-degrees 0.4.10 → 0.5.0

package/lib/notifications.js

@@ -0,0 +1,121 @@
+// Notifications worth opening (Blake, 2026-10-02: "the notifications should be
+// able to be clicked and … take over the right panel and show a more detailed
+// version … what person added back from who and that they are a value person
+// if the score is S … a new person added back, or we got a person from a
+// high-ranking company, or that our scan is done").
+//
+// Each notification carries `data` naming who it is about, so the right panel
+// can show them: { personId?, profileUrl?, viaId?, personIds?, action? }.
+// Older notifications have no data; noteSubject finds their person by the name
+// in the title. Plain functions, no React; tests/notifications.test.mjs.
+
+const HIGH = new Set(['S', 'A']);
+// A company's own score (company_prestige_score, lib/scoring.js) from here up is "a top company".
+export const TOP_COMPANY = 8;
+
+const score1 = (row) => {
+  const n = parseFloat(row?.power_score);
+  return Number.isFinite(n) ? n.toFixed(1) : null;
+};
+
+/** Someone you met through a bridge who is now one of your connections. */
+export function addedBackNotification({ person, via, userId = null }) {
+  if (!person) return null;
+  const tier = person.tier || null;
+  const valued = HIGH.has(tier);
+  return {
+    user_id: userId || null,
+    type: 'added_back',
+    title: `${person.name || 'Someone'} added you back${via?.name ? `, through ${via.name}` : ''}`,
+    message: [tier ? `${tier}-tier${score1(person) ? ` · ${score1(person)}` : ''}` : null, valued ? 'a valuable person to know' : null, person.headline || null]
+      .filter(Boolean).join(' · ').slice(0, 140),
+    icon: valued ? '👑' : '🤝',
+    data: { personId: person.id, viaId: via?.id ?? null, tier },
+  };
+}
+
+/** People a circle scan found at top companies, as one notification. */
+export function topCompanyNotification({ people = [], via = null, userId = null, threshold = TOP_COMPANY }) {
+  const top = people.filter((p) => Number(p?.company_prestige_score) >= threshold)
+    .sort((a, b) => Number(b.company_prestige_score) - Number(a.company_prestige_score) || (parseFloat(b.power_score) || 0) - (parseFloat(a.power_score) || 0));
+  if (!top.length) return null;
+  const companies = [...new Set(top.map((p) => p.company).filter(Boolean))];
+  return {
+    user_id: userId || null,
+    type: 'top_company',
+    title: `${top.length} ${top.length === 1 ? 'person' : 'people'} at top companies${via?.name ? ` in ${via.name}’s circle` : ''}`,
+    message: companies.slice(0, 3).join(', ') + (companies.length > 3 ? ` +${companies.length - 3} more` : ''),
+    icon: '🏢',
+    data: { personIds: top.slice(0, 25).map((p) => p.id), personId: top[0].id, viaId: via?.id ?? null },
+  };
+}
+
+// What each scanner job is called when it's done. Setting up, signing in and
+// saving settings aren't scans, so they leave nothing.
+const SCAN_DONE = {
+  bridge: (t) => `Scan done: ${t?.name ? `${t.name}’s circle` : 'their circle'}`,
+  resume: (t) => `Scan done: ${t?.name ? `${t.name}’s circle` : 'their circle'}`,
+  rescrape: (t) => `Scan done: ${t?.name ? `${t.name}’s circle` : 'their circle'}`,
+  'auto-bridge': () => 'Mapping the 2nd degree: done for now',
+  'auto-bridge-retry': () => 'Retrying hidden lists: done',
+  'resume-all': () => 'Every paused circle: done for now',
+  full: () => 'Your whole network is scanned',
+  refresh: () => 'Check for new: done',
+  company: (t) => `Company scan done${t?.name ? `: ${t.name}` : ''}`,
+  messages: () => 'Messages synced',
+};
+
+/** The notification a finished scan leaves, or null (not a scan, stopped, or it failed). */
+export function scanDoneNotification({ action, target = null, exitCode, stopped = false, log = [], userId = null }) {
+  const name = SCAN_DONE[action];
+  if (!name || stopped || exitCode !== 0) return null;
+  // The last thing the scanner said that sums it up ("Done. 5/5 bridges mapped.").
+  const last = [...log].reverse().map((l) => String(l).trim()).find((l) => l && l !== 'Finished.' && !/^Speed:/.test(l)) || '';
+  return {
+    user_id: userId || null,
+    type: 'scan_done',
+    title: name(target),
+    message: last.slice(0, 140),
+    icon: '📡',
+    data: { action, personId: target?.id ?? null },
+  };
+}
+
+// Older notifications name their person only in the title.
+const NAME_IN_TITLE = [
+  [/^(.+?) accepted!/, 1],
+  [/^High-value connection: (.+)$/, 1],
+  [/^Catalyst discovered: (.+)$/, 1],
+  [/^(.+?) added you back/, 1],
+];
+
+/**
+ * Who a notification is about, from the rows on screen: { person, via, people }.
+ * `via` is who you met them through: the notification's own, else the person's
+ * recorded introducer. `people` are everyone it names (a top-company list).
+ */
+export function noteSubject(note, connections = [], degree2 = []) {
+  const all = [...(connections || []), ...(degree2 || [])];
+  const byId = new Map(all.map((r) => [r.id, r]));
+  const data = typeof note?.data === 'string' ? safeJson(note.data) : note?.data || {};
+  let person = data.personId != null ? byId.get(data.personId) : null;
+  if (!person && data.profileUrl) person = all.find((r) => r.profile_url === data.profileUrl) || null;
+  if (!person) {
+    for (const [re, i] of NAME_IN_TITLE) {
+      const m = String(note?.title || '').match(re);
+      if (!m) continue;
+      const name = m[i].trim().toLowerCase();
+      person = (connections || []).find((r) => String(r.name || '').toLowerCase() === name)
+        || (degree2 || []).find((r) => String(r.name || '').toLowerCase() === name) || null;
+      if (person) break;
+    }
+  }
+  const viaId = data.viaId ?? person?.unlocked_from_bridge_id ?? (person?.degree === 2 ? person.source_connection_id : null);
+  const via = viaId != null ? byId.get(viaId) || null : null;
+  const people = (data.personIds || []).map((id) => byId.get(id)).filter(Boolean);
+  return { person: person || null, via, people, data };
+}
+
+function safeJson(s) {
+  try { return JSON.parse(s); } catch { return {}; }
+}

package/lib/people-map.js

@@ -0,0 +1,82 @@
+// Paths → People: the Paths map with people instead of companies (Blake,
+// 2026-10-02: "basically going to look like map but people based and the
+// bigger circle is their cluster with value"). One bubble per connection of
+// yours, sized by the cluster behind them; a line joins two connections whose
+// clusters share people.
+//
+// Plain functions over the rows the app already has, no React, so
+// tests/people-map.test.mjs runs them as they are.
+
+import { keyFor } from './separation.js';
+
+/** What a cluster is worth: S tier counts 3, A tier 2, everyone else 1. */
+export const clusterValue = ({ size = 0, S = 0, A = 0 } = {}) => size + 2 * S + A;
+
+/**
+ * One entry per connection: { person, id, key, size, S, A, value, only, share }.
+ * `size` is the people in their cluster (each once), `only` how many of those
+ * none of your other connections' clusters hold, `share` = only / size.
+ * Also `links`: [{ a, b, shared }] for every two connections whose clusters
+ * share people, most shared first, and `rank(id)`: the share of your scanned
+ * connections whose cluster is worth less.
+ */
+export function peopleMap(d1 = [], d2 = [], { maxLinks = 400 } = {}) {
+  const ids = new Set((d1 || []).map((c) => c.id));
+  // Each person once per connection whose scan found them.
+  const byConnection = new Map();   // id -> Map(key -> row)
+  const holders = new Map();        // key -> Set(connection id)
+  for (const row of d2 || []) {
+    const from = row?.source_connection_id;
+    if (from == null || !ids.has(from)) continue;
+    const key = keyFor(row);
+    let circle = byConnection.get(from);
+    if (!circle) byConnection.set(from, (circle = new Map()));
+    if (!circle.has(key)) circle.set(key, row);
+    let who = holders.get(key);
+    if (!who) holders.set(key, (who = new Set()));
+    who.add(from);
+  }
+
+  const people = (d1 || []).map((c) => {
+    const circle = byConnection.get(c.id);
+    let S = 0, A = 0, only = 0;
+    if (circle) {
+      for (const [key, row] of circle) {
+        if (row.tier === 'S') S++;
+        else if (row.tier === 'A') A++;
+        if (holders.get(key)?.size === 1) only++;
+      }
+    }
+    const size = circle ? circle.size : 0;
+    return { person: c, id: c.id, key: keyFor(c), size, S, A, value: clusterValue({ size, S, A }), only, share: size ? only / size : 0 };
+  });
+
+  // Two connections whose clusters share people. A person known to many of
+  // your connections would make a line between every two of them, so past
+  // eight holders they are left out of the lines (they still count in `only`).
+  const pairs = new Map();
+  for (const who of holders.values()) {
+    if (who.size < 2 || who.size > 8) continue;
+    const list = [...who].sort();
+    for (let i = 0; i < list.length; i++) {
+      for (let j = i + 1; j < list.length; j++) {
+        const k = `${list[i]}\u0000${list[j]}`;
+        pairs.set(k, (pairs.get(k) || 0) + 1);
+      }
+    }
+  }
+  const links = [...pairs].map(([k, shared]) => {
+    const [a, b] = k.split('\u0000');
+    return { a, b, shared };
+  }).sort((x, y) => y.shared - x.shared || (x.a < y.a ? -1 : 1)).slice(0, maxLinks);
+
+  const values = people.filter((p) => p.size > 0).map((p) => p.value).sort((x, y) => x - y);
+  const rank = (id) => {
+    const p = people.find((x) => x.id === id);
+    if (!p || !p.size || values.length < 2) return null;
+    let below = 0;
+    while (below < values.length && values[below] < p.value) below++;
+    return below / (values.length - 1);
+  };
+  return { people, links, rank };
+}

package/lib/rarity.js

@@ -39,12 +39,15 @@ export function rarityInfo(key) {
 /**
  * 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).
+ * your scanned connections know them (lib/separation.js): never fewer than that.
  */
 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' };
+  const seen = Math.max(1, Math.floor(Number(waysIn) || 1));
+  // Everyone the app found them through is a mutual connection, so a saved
+  // count lower than that is out of date: "only way in" with two ways drawn.
+  if (Number.isFinite(saved) && saved >= seen) return { count: Math.floor(saved), from: 'linkedin' };
+  return { count: seen, from: 'scans' };
 }
 
 /** Someone's rarity: { key, count, from }. */
@@ -78,3 +81,42 @@ export function toggle(set, key) {
   else next.add(key);
   return next;
 }
+
+// ── The Separation slider ──────────────────────────────────────────────────
+// Blake, 2026-10-01: the rare person reachable through one door at one end,
+// the easier, well-connected ones at the other, "so it's seamless"; 2026-10-02:
+// "i want it to be slider ajusted and can be dynmaic". One number, 0 to 100:
+// 0 puts the rarest ways in first, 100 the easiest, and 50 is each person's own
+// score alone, as the list has always been. It reorders; it never changes a
+// score, a tier or a rank. No odds are claimed: the app hasn't measured how
+// often anyone accepts.
+
+export const SLIDER_MIDDLE = 50;
+
+/** How easy the way in is: 0 with one mutual connection, 1 with 31 or more, on a log scale (1→3 counts like 10→30). */
+export function easeOf(count) {
+  const n = Math.max(1, Math.floor(Number(count) || 1));
+  return Math.min(1, Math.log(n) / Math.log(31));
+}
+
+/**
+ * Where someone sorts with the slider at `at`: their score, weighted by how
+ * well their way in fits the end the slider leans to. At 50 it is the score.
+ */
+export function slideValue(score, count, at = SLIDER_MIDDLE) {
+  const lean = (Math.max(0, Math.min(100, Number(at) || 0)) - SLIDER_MIDDLE) / SLIDER_MIDDLE;   // -1 rare … +1 easy
+  if (!lean) return score;
+  const ease = easeOf(count);
+  const pull = Math.abs(lean);
+  return score * (1 - pull + pull * (lean < 0 ? 1 - ease : ease));
+}
+
+/** What the slider is doing at `at`, in words: { name, detail }. */
+export function slideLabel(at = SLIDER_MIDDLE) {
+  const v = Math.max(0, Math.min(100, Math.round(Number(at) || 0)));
+  if (v <= 10) return { name: 'Rarest first', detail: 'Strong people with one way in: the connection who knows them is the only door you have.' };
+  if (v < 45) return { name: 'Leaning rare', detail: 'Strong people with few mutual connections move up; the ones everybody knows move down.' };
+  if (v <= 55) return { name: 'By power', detail: 'Each person’s own score alone. How many of your connections know them doesn’t change the order.' };
+  if (v < 90) return { name: 'Leaning easy', detail: 'Strong people you share more mutual connections with move up: more people who could introduce you.' };
+  return { name: 'Easiest first', detail: 'Strong people you share the most mutual connections with: the warmest introductions. All the way right, the map aims at whoever you share the most with, with the ones in circles you haven’t scanned yet as grey dots.' };
+}

package/lib/reach.js

@@ -20,6 +20,7 @@
 //
 // Plain functions, no React; tests/reach.test.mjs.
 
+import { paceSeconds } from './scan-pace.js';
 import { keyFor, compareBridges } from './separation.js';
 
 /**
@@ -107,13 +108,13 @@ export function readyByCircle(reach) {
  * 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) {
+export function circleScanCost(pages = 100, pace = 'fast') {
   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)),
-  };
+  // At Fast, as it has always been said; slower speeds add their waits (lib/scan-pace.js).
+  const minutes = !pace || pace === 'fast'
+    ? (searches >= 100 ? 55 : Math.max(5, Math.round(searches * 0.55)))
+    : Math.max(5, Math.round(paceSeconds(pace, searches) / 60));
+  return { profileViews: 1, searches, minutes };
 }
 
 /**

package/lib/rpc.js

@@ -7,6 +7,7 @@ import { getDb, newId, nowIso } from './db-client.js';
 // for the routes that call it; it rescores with lib/scoring.js like the rest.
 
 import { readNetwork, scoreNetwork, explainScore, SCORING_VERSION, KNOWN_COMPANIES, COMPANY_DATA, RULE_TABLES, TIER_SCALE_SETTING } from './scoring.js';
+import { TITLE_RANKING_SETTING, isDefaultRanking, rankingFingerprint } from './title-ranking.js';
 import { industryKeyOf, INDUSTRIES } from './companies.js';
 import { readSettings } from './settings.js';
 import { SECTOR_FOCUS_SETTING, focusFingerprint, previewSectorFocus } from './sector-focus.js';
@@ -69,6 +70,12 @@ export function tierScaleOf(db = getDb()) {
   return readSettings(db, { tierScale: TIER_SCALE_SETTING }).tierScale;
 }
 
+/** Your title ranking (Settings → Scores → Titles), or null when you haven't changed one. */
+export function titleRankingOf(db = getDb()) {
+  const r = readSettings(db, { titleRanking: TITLE_RANKING_SETTING }).titleRanking;
+  return isDefaultRanking(r) ? null : r;
+}
+
 /**
  * What rescoring reads: every row, as scoring needs it. `withPeople` adds each
  * row's name, for naming who a change would move.
@@ -111,12 +118,13 @@ export function rescoreAll({ compareWith } = {}) {
   const overrides = companyOverrides(db);
   const focus = sectorFocusOf(db);
   const tierScale = tierScaleOf(db);
+  const titles = titleRankingOf(db);
   // Every headline is read once, however many ways the rows are then scored.
   const read = readForScoring(rows);
-  const { scores } = scoreNetwork(rows, { overrides, focus, tierScale, read });
+  const { scores } = scoreNetwork(rows, { overrides, focus, tierScale, titles, 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, tierScale, examples: 0 });
+    : previewSectorFocus(rows, { overrides, read, from: compareWith, to: focus, tierScale, titles, 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 = ?`);
@@ -144,6 +152,7 @@ export function rescoreAll({ compareWith } = {}) {
     meta.run('scoring_list', KNOWN_LIST_STAMP);
     meta.run('scoring_focus', focusFingerprint(focus));
     meta.run('scoring_tiers', tierScale);
+    meta.run('scoring_titles', rankingFingerprint(titles || undefined));
     db.exec('COMMIT');
   } catch (err) {
     db.exec('ROLLBACK');
@@ -154,7 +163,7 @@ export function rescoreAll({ compareWith } = {}) {
 
 /**
  * Rescore once if the stored scores came from an older scoring model or
- * curated list, or from a sector focus or tier scale other than the one saved
+ * curated list, or from a sector focus, tier scale or title ranking other than the one saved
  * now: an update, a database restored or brought from another computer, or a
  * Settings save whose rescore never finished.
  */
@@ -164,7 +173,9 @@ export function rescoreIfStale() {
   const fresh = meta('scoring_version') === String(SCORING_VERSION)
     && meta('scoring_list') === KNOWN_LIST_STAMP
     && meta('scoring_focus') === focusFingerprint(sectorFocusOf(db))
-    && meta('scoring_tiers') === tierScaleOf(db);
+    && meta('scoring_tiers') === tierScaleOf(db)
+    // Scores from before title rankings existed have no stamp, and none is the same as no ranking.
+    && (meta('scoring_titles') ?? 'none') === rankingFingerprint(titleRankingOf(db) || undefined);
   return fresh ? { scored: 0 } : rescoreAll();
 }
 

package/lib/scan-pace.js

@@ -0,0 +1,46 @@
+// The Scan page's speed: Fast, Medium or Slow (Blake, 2026-09-30: "a bar that
+// will adjust the scanner from slow, medium and fast… the current is
+// considered fast, and then we lower to medium and slow, bogging it down,
+// making it less likely to get caught, and estimated time for each").
+//
+// Fast is today's pacing and nothing is faster; Medium and Slow only add
+// waiting. Speed changes searches an hour, never searches a day: the daily
+// budget is still the volume cap. scripts/scrape.py SCAN_PACES holds the same
+// numbers (tests/scan-pace.test.mjs checks they agree). Fixed waits, never
+// random "human" timing: the point is fewer searches an hour, not disguise.
+
+export const PACES = {
+  fast: { label: 'Fast', pagePause: 20, chunkCooldown: 60, profileGap: 60 },
+  medium: { label: 'Medium', pagePause: 45, chunkCooldown: 180, profileGap: 90 },
+  slow: { label: 'Slow', pagePause: 90, chunkCooldown: 300, profileGap: 120 },
+};
+export const PACE_NAMES = ['slow', 'medium', 'fast'];
+export const DEFAULT_PACE = 'fast';
+// About how long reading one page of results takes, measured in 0.1.6.
+export const WORK_SECONDS = 6;
+const EVERY = 10;   // the longer rest comes after every 10 pages (scrape.py SAVE_EVERY_PAGES)
+
+export const paceOf = (name) => PACES[name] || PACES[DEFAULT_PACE];
+
+/** Seconds to run `searches` searches at a speed: the work, the rest before each, the longer rest every 10. */
+export function paceSeconds(name, searches) {
+  const p = paceOf(name);
+  const n = Math.max(0, Math.floor(Number(searches) || 0));
+  return n * (WORK_SECONDS + p.pagePause) + Math.floor(n / EVERY) * p.chunkCooldown;
+}
+
+/** About how many searches an hour a speed makes. */
+export function searchesPerHour(name) {
+  const p = paceOf(name);
+  return Math.round(3600 / (WORK_SECONDS + p.pagePause + p.chunkCooldown / EVERY));
+}
+
+/** "about 1 h 7 min", "about 27 min", "under a minute" */
+export function durationText(seconds) {
+  if (!(seconds >= 60)) return 'under a minute';
+  const m = Math.round(seconds / 60);
+  if (m < 60) return `about ${m} min`;
+  const h = Math.floor(m / 60);
+  const rest = m % 60;
+  return `about ${h} h${rest ? ` ${rest} min` : ''}`;
+}

package/lib/scoring.js

@@ -2512,18 +2512,47 @@ export function readPerson(row) {
  * points whatever else they list. `companyFor(name)` returns companyScore();
  * `read` is the row's readPerson(), when it has been read already.
  */
-/** A role's title points as they count: 70% for a former role, capped for a student. */
-function rolePoints(role, student) {
-  const points = role.title.points * (role.former ? FORMER_WEIGHT : 1);
+/** Does this title text have the words? Whole words only: "vc" isn't in "dvc", "cto" isn't in "doctor". */
+const titlePatterns = new Map();
+export function titleHas(text, words) {
+  let re = titlePatterns.get(words);
+  if (!re) {
+    const esc = words.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    re = new RegExp(`(^|[^a-z0-9])${esc}($|[^a-z0-9])`);
+    if (titlePatterns.size > 500) titlePatterns.clear();
+    titlePatterns.set(words, re);
+  }
+  return re.test(String(text || '').toLowerCase());
+}
+
+/**
+ * A title's points under your title ranking (Settings → Scores → Titles,
+ * lib/title-ranking.js): a role whose words are in it counts what you gave
+ * that role (the highest, if several match), else the level counts your
+ * points for it, else the model's. No ranking: the model's.
+ */
+export function rankedPoints(role, titles) {
+  if (!titles) return role.title.points;
+  let match = null;
+  for (const r of titles.roles || []) {
+    if (titleHas(role.part, r.text) && (match == null || r.points > match)) match = r.points;
+  }
+  if (match != null) return match;
+  return titles.points?.[role.title.key] ?? role.title.points;
+}
+
+/** A role's title points as they count: yours where you ranked them, 70% for a former role, capped for a student. */
+function rolePoints(role, student, titles) {
+  const points = rankedPoints(role, titles) * (role.former ? FORMER_WEIGHT : 1);
   return student ? Math.min(points, STUDENT_CAP) : points;
 }
 
-export function scorePerson(row, companyFor = (name) => companyScore(name), read = readPerson(row)) {
+export function scorePerson(row, companyFor = (name) => companyScore(name), read = readPerson(row), titles = null) {
   const { roles, student, reach } = read;
   let best = null;
   for (const role of roles) {
     const co = companyFor(role.company);
-    const points = rolePoints(role, student);
+    const points = rolePoints(role, student, titles);
     const core = points * (0.45 + 0.055 * co.score);
     if (!best || core > best.core) best = { role, co, points, core };
   }
@@ -2535,6 +2564,8 @@ export function scorePerson(row, companyFor = (name) => companyScore(name), read
   const bonus = reachBonus(row?.headline, unknown ? 4 : best.co.base ?? best.co.score, reach);
   const power = round1(best.core + bonus.points);
   const title = { ...best.role.title, former: best.role.former, student, points: round1(best.points) };
+  // Your ranking moved it: the card's "why" says so.
+  if (titles && rankedPoints(best.role, titles) !== best.role.title.points) title.ranked = true;
   if (best.role.former) title.label = `Former ${title.label}`;
   if (student && best.role.title.level > 0) title.label = `Student · ${title.label}`;
   const out = { title, company: best.role.company, companyScore: best.co.score, companySource: best.co.source, bonus, power, tier: tierFor(power) };
@@ -2652,7 +2683,7 @@ export function explainScore(s, boost = 0, { sectorLabel } = {}) {
   const co = s.companySector
     ? `${s.company} (${s.companyScore}/10: ${s.companySector.base} + ${s.companySector.bonus} your sector${which ? `: ${which}` : ''})`
     : `${s.company || 'no company found'} (${s.companyScore}/10${s.companySource === 'yours' ? ', your score' : ''})`;
-  const bits = [`${s.title.label} (${s.title.points})`, co];
+  const bits = [`${s.title.label} (${s.title.points}${s.title.ranked ? ', your ranking' : ''})`, co];
   if (s.bonus.points) bits.push(`+${s.bonus.points} ${s.bonus.reasons.join(', ')}`);
   if (boost) bits.push(`+${boost} strong circle`);
   return bits.join(' · ');
@@ -2716,7 +2747,7 @@ export function readNetwork(rows = [], { industryOf, sectorsOf, groupOf } = {})
  * (companyScore(), by name) and the curve's cut-offs (null on the fixed scale).
  */
 export function scoreNetwork(rows = [], {
-  overrides = new Map(), industryOf, sectorsOf, groupOf, focus, tierScale = 'fixed',
+  overrides = new Map(), industryOf, sectorsOf, groupOf, focus, tierScale = 'fixed', titles = null,
   read = readNetwork(rows, { industryOf, sectorsOf, groupOf }),
 } = {}) {
   // Each company is scored once; everyone there shares the answer.
@@ -2726,7 +2757,7 @@ export function scoreNetwork(rows = [], {
     return companyScores.get(name);
   };
   const out = new Map();
-  for (const r of rows) out.set(r.id, { ...scorePerson(r, companyFor, read.people.get(r)), boost: 0 });
+  for (const r of rows) out.set(r.id, { ...scorePerson(r, companyFor, read.people.get(r), titles), boost: 0 });
   // The curve's cut-offs come from your 1st-degree people before any circle
   // boost, so a boost (which reads the graded tiers) can't move its own cut-off.
   const cutoffs = tierScale === 'fixed' ? null

package/lib/scraper-client.js

@@ -15,11 +15,27 @@ export async function scraperStatus() {
   return r.json();
 }
 
+/**
+ * Scan page → "Hide the Chrome window while scanning", remembered in this
+ * browser. Every way a scan starts asks here: the Scan page's own buttons used
+ * to post straight to the scanner without it, so the switch did nothing for
+ * the scans started from the very page it sits on.
+ */
+export const HIDE_CHROME_KEY = 'six-degrees-hide-chrome';
+export function hideChromeOn(storage = typeof localStorage !== 'undefined' ? localStorage : null) {
+  try { return JSON.parse(storage?.getItem(HIDE_CHROME_KEY) || 'false') === true; } catch { return false; }
+}
+
+/** What a scan start sends: the action, its details, and `headless` when Chrome is to stay hidden. */
+export function scanRequest(action, extra = {}, hidden = hideChromeOn()) {
+  return { action, ...extra, ...(hidden ? { headless: true } : {}) };
+}
+
 export async function startScrape(action, name, extra = {}) {
   const r = await fetch('/api/scraper', {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ action, ...(name ? { name } : {}), ...extra }),
+    body: JSON.stringify(scanRequest(action, { ...(name ? { name } : {}), ...extra })),
   });
   const d = await r.json().catch(() => ({}));
   if (!r.ok) throw new Error(d.error || 'Could not start the scanner.');
@@ -211,11 +227,8 @@ export async function beginScrape(action, { name, id, onLog, ...extra } = {}) {
   });
   let started;
   try {
-    // Scan page → "Hide the Chrome window while scanning", remembered in this
-    // browser, applies to every scan however it was started.
-    let hidden = false;
-    try { hidden = JSON.parse(localStorage.getItem('six-degrees-hide-chrome') || 'false') === true; } catch {}
-    started = await startScrape(action, name, { ...(id ? { id } : {}), ...(hidden ? { headless: true } : {}), ...extra });
+    // startScrape adds "Hide the Chrome window" itself (scanRequest), however the scan was started.
+    started = await startScrape(action, name, { ...(id ? { id } : {}), ...extra });
   } catch (err) {
     // Refused, often because something else runs: ask what, straight away.
     // Until the answer comes, only our own claim is taken back.

package/lib/sector-focus.js

@@ -141,11 +141,11 @@ export function tierMoves(rows, tierBefore, tierAfter, { examples = 5, companyOf
  */
 export function previewSectorFocus(rows = [], {
   overrides = new Map(), industryOf, sectorsOf = sectorMatcher(), groupOf = sectorGroup, from = NO_FOCUS, to = NO_FOCUS, examples = 5,
-  tierScale, read = readNetwork(rows, { industryOf, sectorsOf, groupOf }),
+  tierScale, titles = null, read = readNetwork(rows, { industryOf, sectorsOf, groupOf }),
 } = {}) {
-  // Both on the tier scale saved now (Scores → Tiers), as rescoring grades them.
-  const before = scoreNetwork(rows, { overrides, focus: from, tierScale, read });
-  const after = scoreNetwork(rows, { overrides, focus: to, tierScale, read });
+  // Both on the tier scale and title ranking saved now (Scores → Tiers, Titles), as rescoring grades them.
+  const before = scoreNetwork(rows, { overrides, focus: from, tierScale, titles, read });
+  const after = scoreNetwork(rows, { overrides, focus: to, tierScale, titles, read });
 
   // Companies whose score moves, biggest first (by your people there now).
   // Every company anyone names counts, a former employer too: its score moves