six-degrees 0.3.0 → 0.4.0

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

@@ -1,4 +1,5 @@
-import { scorePerson } from './scoring.js';
+import { scorePerson, curveCutoffs, curvedTier } from './scoring.js';
+import { toIsoDate } from './ingest.js';
 // LinkedIn Connections.csv import — parsed ENTIRELY in the browser.
 //
 // Nothing is uploaded and nothing is written to the database: an imported
@@ -49,6 +50,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;
@@ -122,12 +137,9 @@ export function parseConnectionsCsv(text) {
     if (seen.has(id)) { skipped++; continue; }
     seen.add(id);
 
-    let connected_date = null;
-    const raw = cell(iConnected);
-    if (raw) {
-      const d = new Date(raw);
-      if (!isNaN(d.getTime())) connected_date = d.toISOString().split('T')[0];
-    }
+    // "28 Sep 2026", read as the calendar date it is. new Date(raw).toISOString()
+    // made it local midnight in UTC, a day early anywhere east of London.
+    const connected_date = toIsoDate(cell(iConnected));
 
     connections.push(connectionFrom({ id, name, role, company, profileUrl, connected_date }));
   }
@@ -138,7 +150,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 +173,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/lib/data-export.js

@@ -111,7 +111,8 @@ export function buildExport(db, { dir, outFile, includePhotos = true, appVersion
     // file the other computer doesn't have: some views draw an empty circle
     // for it. With no photo, they show initials, and the next scan of that
     // person saves a new one. A photo not saved yet (LinkedIn's own link,
-    // which expires in a few weeks) is left as it is, as it is here.
+    // which expires in a few weeks) is left as it is, as it is here: neither
+    // computer shows it, and either saves it once (lib/photos.js).
     if (!includePhotos) {
       out.exec("UPDATE linkedin_connections SET profile_image_url = NULL WHERE profile_image_url LIKE '/avatars/%'");
     }

package/lib/data-folder.js

@@ -11,9 +11,11 @@
 import { readdirSync, lstatSync, existsSync, rmSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 import path from 'node:path';
+import { AVATAR_FILE } from './photos.js';
 
-/** A photo the /avatars route serves: a plain file name, no folders. The route uses this same pattern. */
-export const AVATAR_FILE = /^[A-Za-z0-9_-]+\.(webp|jpg|jpeg|png)$/;
+// A photo the /avatars route serves (lib/photos.js). An export carries and an
+// import accepts exactly those names.
+export { AVATAR_FILE };
 
 /**
  * The scanner's notes about the network itself: without them, people whose

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

@@ -0,0 +1,12 @@
+// The Galaxy's view, as numbers, kept apart from the drawing so it can be tested
+// (app/components/ForceGraph.js).
+
+/**
+ * The same view in a box of a new size. It moves by half the change, at the
+ * same zoom, so whatever was in the middle of the box is in the middle still.
+ * Opening a 320-pixel panel slides the view 160 pixels left, and closing it
+ * slides the view back to exactly where it was.
+ */
+export function recentre({ x, y, k }, from, to) {
+  return { x: x + (to.width - from.width) / 2, y: y + (to.height - from.height) / 2, k };
+}

package/lib/ingest.js

@@ -43,22 +43,29 @@ const MONTHS = ['january', 'february', 'march', 'april', 'may', 'june', 'july',
   'august', 'september', 'october', 'november', 'december'];
 
 /**
- * "September 22, 2026" (as LinkedIn prints "Connected on …") → "2026-09-22".
+ * A date as LinkedIn writes it → "2026-09-22": "September 22, 2026" (a profile's
+ * "Connected on …", read by the scanner) or "22 Sep 2026" (the "Connected On"
+ * column of the Connections.csv export, read by lib/csv.js).
  *
  * Parsed by hand rather than with new Date(text).toISOString(): that reads the
  * text as local midnight and converts to UTC, which moves the date back a day
  * anywhere east of Greenwich — and throws outright on text it cannot read.
- * Returns null for anything it does not recognise.
+ * A calendar date has no time zone, so nothing here uses one.
+ * Returns null for anything it does not recognise, or a day the month doesn't have.
  */
 export function toIsoDate(text) {
   const t = String(text || '').trim();
   if (/^\d{4}-\d{2}-\d{2}$/.test(t)) return t;
-  const m = t.match(/^([A-Za-z]+)\.?\s+(\d{1,2}),?\s+(\d{4})$/);
-  if (!m) return null;
-  const month = MONTHS.findIndex((name) => name.startsWith(m[1].toLowerCase()) && m[1].length >= 3);
-  const day = Number(m[2]);
-  if (month < 0 || day < 1 || day > 31) return null;
-  return `${m[3]}-${String(month + 1).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+  let name, day, year;
+  let m = t.match(/^([A-Za-z]+)\.?\s+(\d{1,2}),?\s+(\d{4})$/);   // September 22, 2026
+  if (m) [, name, day, year] = m;
+  else if ((m = t.match(/^(\d{1,2})\s+([A-Za-z]+)\.?\s+(\d{4})$/))) [, day, name, year] = m;   // 22 Sep 2026
+  else return null;
+  const month = MONTHS.findIndex((full) => full.startsWith(name.toLowerCase()) && name.length >= 3);
+  day = Number(day);
+  // Day 0 of the next month is this month's last, counted in UTC so no zone moves it.
+  if (month < 0 || day < 1 || day > new Date(Date.UTC(Number(year), month + 1, 0)).getUTCDate()) return null;
+  return `${year}-${String(month + 1).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
 }
 
 // Tiers that make a new connection worth a notification of its own.
@@ -100,3 +107,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/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/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/lib/linkedin-limits.js

@@ -4,15 +4,20 @@
 // reads them with the same rules, and writes only the two things a person
 // changes here — the budget, and lifting a cooldown.
 //
+// The budget is searches (a day and a month) and profile views (a day). Profile
+// views are what got an account restricted (TRAPS §16), so their cap has no
+// "no limit", and the scanner also keeps any two a minute apart.
+//
 // They belong to the LinkedIn account, not to a profile in the app. TRAPS §35.
 
 import { readFileSync, writeFileSync, renameSync, unlinkSync, existsSync, lstatSync } from 'node:fs';
 import path from 'node:path';
 import { durable } from './durable.js';
 
-export const DEFAULT_LIMITS = { daily: 50, monthly: 250 };
+export const DEFAULT_LIMITS = { daily: 50, monthly: 250, profiles: 50 };
 export const DAILY_CHOICES = [25, 50, 100, 200, 500];
 export const MONTHLY_CHOICES = [100, 250, 500, 1000, 0];   // 0 = no monthly cap (Premium)
+export const PROFILE_CHOICES = [10, 25, 50, 100];           // profile views a day; never unlimited
 const DAY = 24 * 3600;
 const PACIFIC = 'America/Los_Angeles';
 
@@ -56,15 +61,25 @@ export function nextMonthStartPacific(ms = Date.now()) {
 export function readLimits(dir) {
   const raw = readJson(path.join(dir, 'scan-limits.json')) || {};
   const num = (v, d) => (Number.isInteger(v) && v >= 0 ? v : d);
-  return { daily: num(raw.daily, DEFAULT_LIMITS.daily), monthly: num(raw.monthly, DEFAULT_LIMITS.monthly) };
+  return {
+    daily: num(raw.daily, DEFAULT_LIMITS.daily),
+    monthly: num(raw.monthly, DEFAULT_LIMITS.monthly),
+    // 0 is "no limit" for searches; for profile views the scanner reads it as the default.
+    profiles: num(raw.profiles, 0) || DEFAULT_LIMITS.profiles,
+  };
 }
 
-/** Only the offered choices are accepted, like everything else that reaches the scanner. */
-export function writeLimits(dir, { daily, monthly }) {
+/**
+ * Only the offered choices are accepted, like everything else that reaches the
+ * scanner. A value not given keeps what is saved: every key is written back,
+ * or saving one would drop the others to their defaults.
+ */
+export function writeLimits(dir, { daily, monthly, profiles } = {}) {
   const cur = readLimits(dir);
   const next = {
     daily: DAILY_CHOICES.includes(daily) ? daily : cur.daily,
     monthly: MONTHLY_CHOICES.includes(monthly) ? monthly : cur.monthly,
+    profiles: PROFILE_CHOICES.includes(profiles) ? profiles : cur.profiles,
   };
   writeJsonAtomic(path.join(dir, 'scan-limits.json'), next);
   return next;
@@ -72,13 +87,14 @@ export function writeLimits(dir, { daily, monthly }) {
 
 /**
  * Searches in the last 24 hours and since LinkedIn's month began, and profile
- * views today. An unreadable record reads as the day used up, as the scanner
- * treats it — failing open would say nothing had been searched.
+ * views in the last 24 hours. An unreadable record reads as the day used up,
+ * searches and profile views both, as the scanner treats it — failing open
+ * would say nothing had been searched.
  */
 export function usage(dir, now = Date.now()) {
   const file = path.join(dir, 'linkedin-activity.json');
   const data = existsSync(file) ? readJson(file) : { searches: [], profiles: [] };
-  if (!data || typeof data !== 'object') return { searchesToday: Infinity, searchesMonth: 0, profilesToday: 0, unreadable: true };
+  if (!data || typeof data !== 'object') return { searchesToday: Infinity, searchesMonth: 0, profilesToday: Infinity, unreadable: true };
   const s = (Array.isArray(data.searches) ? data.searches : []).map(Number);
   const p = (Array.isArray(data.profiles) ? data.profiles : []).map(Number);
   const dayAgo = now / 1000 - DAY;
@@ -113,6 +129,7 @@ export function linkedinState(dir, now = Date.now()) {
     limits,
     leftToday: left(limits.daily, use.searchesToday),
     leftMonth: left(limits.monthly, use.searchesMonth),
+    profilesLeftToday: left(limits.profiles, use.profilesToday),
     monthResets: nextMonthStartPacific(now),
     cooldown: readCooldown(dir, now),
   };
@@ -138,7 +155,8 @@ const isTime = (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0;
  * Why one of these files from another computer can't be used here, in words
  * for the page, or null when it can. The limits follow writeLimits: only the
  * menu's own choices. A value the app never offers is refused rather than
- * passed to the scanner, which reads a daily limit of 0 as "no limit at all".
+ * passed to the scanner, which reads a daily limit of 0 as "no limit at all"
+ * (and 1000 profile views a day would be as good as none).
  */
 export function budgetFileProblem(name, data) {
   if (!isObject(data)) return 'it is not a JSON object';
@@ -155,6 +173,9 @@ export function budgetFileProblem(name, data) {
     if (data.monthly !== undefined && !MONTHLY_CHOICES.includes(data.monthly)) {
       return `its monthly limit (${String(data.monthly).slice(0, 20)}) is not one Six Degrees offers`;
     }
+    if (data.profiles !== undefined && !PROFILE_CHOICES.includes(data.profiles)) {
+      return `its limit on profile views (${String(data.profiles).slice(0, 20)}) is not one Six Degrees offers`;
+    }
   }
   return null;
 }
@@ -236,6 +257,7 @@ export function mergeBudgetFiles({ dir, from }) {
     durable.writeJsonDurably(here(LIMITS), {
       daily: limits.daily ?? DEFAULT_LIMITS.daily,
       monthly: limits.monthly ?? DEFAULT_LIMITS.monthly,
+      profiles: limits.profiles ?? DEFAULT_LIMITS.profiles,
     });
   }
 }

package/lib/photos.js

@@ -0,0 +1,47 @@
+// Profile photos are shown from this computer only.
+//
+// The scanner saves each photo into the data folder as it reads it
+// (scripts/image_store.py), and the row points at the saved file,
+// `/avatars/<name>`, which app/avatars/[file] serves. A row can also hold a
+// link: LinkedIn's own, which older versions stored until the scanner replaced
+// it, and which a copy of a network made by one carries too. A page never loads
+// a link: it would contact LinkedIn while someone is only looking at their map,
+// and the app goes online only when you act. That person shows initials until
+// the photo is saved, at the next scan or with Save photos on the Scan page.
+// The Content-Security-Policy in next.config.mjs holds the same line in the
+// browser.
+//
+// No imports, so the views and the server share it: every view and the routes
+// that store photos check with localPhoto, and the /avatars route serves the
+// names AVATAR_FILE allows.
+
+/** A photo the /avatars route serves: a plain file name, no folders. The route uses this same pattern. */
+export const AVATAR_FILE = /^[A-Za-z0-9_-]+\.(webp|jpg|jpeg|png)$/;
+
+const PREFIX = '/avatars/';
+
+/** The photo to show for a row's `profile_image_url`: its saved file's path, or null. */
+export function localPhoto(url) {
+  if (typeof url !== 'string' || !url.startsWith(PREFIX)) return null;
+  return AVATAR_FILE.test(url.slice(PREFIX.length)) ? url : null;
+}
+
+/**
+ * The photos still kept as links, one per person and link:
+ * [{ profileUrl, imageUrl }]. `db` is an open node:sqlite database. The
+ * scanner saves each (`GET /api/update-images`), or forgets the link on a
+ * definite no, so a link is tried until there's an answer.
+ */
+export function waitingPhotos(db) {
+  return db.prepare(`SELECT DISTINCT profile_url AS profileUrl, profile_image_url AS imageUrl
+      FROM linkedin_connections
+     WHERE profile_image_url IS NOT NULL AND profile_image_url <> ''
+       AND substr(profile_image_url, 1, 9) <> '/avatars/'
+     ORDER BY profile_url`).all()
+    .filter((r) => r.profileUrl && !localPhoto(r.imageUrl));
+}
+
+/** How many people have a photo waiting to be saved. */
+export function waitingPhotoCount(db) {
+  return new Set(waitingPhotos(db).map((r) => r.profileUrl)).size;
+}

package/lib/quest.js

@@ -9,6 +9,8 @@
 // sent, people who actually joined your network), never from browsing.
 // Plain functions; tests/quest.test.mjs.
 
+import { circleState } from './reach.js';
+
 export const STAGE_SIZE = 5;
 export const XP_SEND = { S: 25, A: 15, B: 10, C: 5, D: 2 };
 export const XP_ADDED = { S: 100, A: 60, B: 35, C: 15, D: 5 };
@@ -26,8 +28,9 @@ export function levelFor(points) {
  * @param sentIds ids marked "invite sent"
  * @param added   1st-degree people who came through a cluster (unlocked_from_bridge_id set)
  * @param mappedIds ids of 1st-degree people whose own circle is mapped
+ * @param reach   lib/reach.js reachIndex(), which also knows hidden lists; mappedIds stands in without it
  */
-export function buildQuest({ recs = [], sentIds = new Set(), added = [], mappedIds = new Set() }) {
+export function buildQuest({ recs = [], sentIds = new Set(), added = [], mappedIds = new Set(), reach = null }) {
   const byBridge = new Map();
   const seen = new Set();
   for (const r of [...recs].sort((a, b) => (b.priority || 0) - (a.priority || 0))) {
@@ -112,8 +115,10 @@ export function buildQuest({ recs = [], sentIds = new Set(), added = [], mappedI
     level: levelFor(points),
     sentTotal,
     addedTotal,
-    // People you've added whose own circle isn't mapped yet: the next degree.
-    newDoors: added.filter((a) => a.unlocked_from_bridge_id && !mappedIds.has(a.id)),
+    // People you've added whose own circle can be scanned: the next degree.
+    // Hidden lists aren't doors (lib/reach.js, the rule Bridge Chains uses).
+    newDoors: added.filter((a) => a.unlocked_from_bridge_id
+      && circleState(a, reach || { scanned: mappedIds, hidden: new Set() }) === 'todo'),
     clearedStages: clusters.reduce((s, c) => s + (c.stage - 1) + (c.complete ? 1 : 0), 0),
   };
 }