six-degrees 0.4.10 → 0.5.0

package/.next/standalone/lib/settings-effects.js

@@ -5,28 +5,37 @@
 
 import { rescoreAll } from './rpc.js';
 import { sameFocus, NO_FOCUS, tierMoves } from './sector-focus.js';
+import { rankingFingerprint } from './title-ranking.js';
 
 // Each entry: `changed(before, after)` says whether a change matters (by
 // default, any change to the stored value), and `run(db, after, before)` does
 // the work and returns what to tell the page.
+// Rescore everyone and count who changed tier, from the stored tiers before and after.
+function rescoreCountingMoves(db) {
+  const rows = () => db.prepare('SELECT id, degree, profile_url, tier FROM linkedin_connections').all();
+  try {
+    const before = new Map(rows().map((r) => [r.id, r.tier]));
+    const { scored } = rescoreAll();
+    const { people, up, down } = tierMoves(rows(), (r) => before.get(r.id), (r) => r.tier, { examples: 0 });
+    return { scored, people, moved: up + down, up, down };
+  } catch (err) {
+    throw new Error(`Saved, but rescoring your network failed (${err.message}). It will try again the next time the map loads.`);
+  }
+}
+
 const EFFECTS = {
+  // Title points are part of everyone's score, so a new ranking rescores everyone, as a new tier scale does.
+  titleRanking: {
+    changed: (before, after) => rankingFingerprint(before) !== rankingFingerprint(after),
+    run: (db) => rescoreCountingMoves(db),
+  },
   tierScale: {
     // Tiers are graded when everyone is scored, so a new scale rescores
     // everyone. The answer counts who changed tier, from the stored tiers
     // before and after, with the sector focus's own counter (tierMoves): a
     // person reachable through two bridges is two rows but one person, counted
     // once at their closest degree.
-    run(db) {
-      const rows = () => db.prepare('SELECT id, degree, profile_url, tier FROM linkedin_connections').all();
-      try {
-        const before = new Map(rows().map((r) => [r.id, r.tier]));
-        const { scored } = rescoreAll();
-        const { people, up, down } = tierMoves(rows(), (r) => before.get(r.id), (r) => r.tier, { examples: 0 });
-        return { scored, people, moved: up + down, up, down };
-      } catch (err) {
-        throw new Error(`Saved, but rescoring your network failed (${err.message}). It will try again the next time the map loads.`);
-      }
-    },
+    run: (db) => rescoreCountingMoves(db),
   },
   sectorFocus: {
     // Only a change to what scoring uses: a strength with no sectors picked

package/.next/standalone/lib/settings.js

@@ -12,6 +12,7 @@
 
 import { SECTOR_FOCUS_SETTING, FIELD_ASKED_SETTING } from './sector-focus.js';
 import { TIER_SCALE_SETTING } from './scoring.js';
+import { TITLE_RANKING_SETTING } from './title-ranking.js';
 
 export const SETTINGS = {
   // Scores → Your sector: industries whose companies count for more (lib/sector-focus.js).
@@ -20,6 +21,8 @@ export const SETTINGS = {
   fieldAsked: FIELD_ASKED_SETTING,
   // Scores → Tiers: graded on your network's curve, or on the fixed scale (lib/scoring.js).
   tierScale: TIER_SCALE_SETTING,
+  // Scores → Titles: how much each kind of title counts, and roles you're looking for (lib/title-ranking.js).
+  titleRanking: TITLE_RANKING_SETTING,
 };
 
 const KEY = 'settings';

package/.next/standalone/lib/social-crm.js

@@ -0,0 +1,415 @@
+// The Social tab's CRM: one place for everyone you've been in touch with on
+// LinkedIn, and your own notes on them.
+//
+// Blake, 2026-09-29: "it doesn't show all the conversations and sent messages;
+// this needs to be a full CRM with past conversations, current ones, sent out,
+// etc." The Conversations list showed only connections, and nothing you'd
+// sent that wasn't a message. Here every person you've messaged, asked to
+// connect, been asked by, or tracked a request to in the app is one contact,
+// connection or not, with:
+//
+//   what LinkedIn says   their conversations (export and live sync), requests
+//                        both ways (Invitations.csv), the app's own tracked
+//                        requests (the Outlink queue's "Mark sent")
+//   what you say         a stage, tags, notes and a next follow-up date: yours,
+//                        kept per profile in crm-<profile>.json
+//                        (app/api/social/crm), always, whatever the Keep my
+//                        messages switch says, because you wrote them
+//
+// and the views: Inbox (waiting on you), Awaiting reply (you wrote last, no
+// answer for N days), Follow-ups due, Pipeline (by stage), Sent, Received, All.
+//
+// Plain functions, no React; tests/social-crm.test.mjs.
+
+import { keyFor, routeIndex, routesFor } from './separation.js';
+import { nameKey } from './linkedin-export.js';
+
+const DAY = 86400000;
+
+export const STAGES = Object.freeze([
+  { id: 'new', label: 'New' },
+  { id: 'contacted', label: 'Contacted' },
+  { id: 'replied', label: 'Replied' },
+  { id: 'meeting', label: 'Meeting' },
+  { id: 'won', label: 'Won/Partner' },
+  { id: 'not-now', label: 'Not now' },
+]);
+const STAGE_IDS = new Set(STAGES.map((s) => s.id));
+export const stageLabel = (id) => STAGES.find((s) => s.id === id)?.label || '';
+
+/** Awaiting reply: you wrote last, and nothing came back for this many days. */
+export const AWAIT_DAYS = 7;
+const MAX_NOTES = 20000;
+const MAX_TAGS = 30;
+const MAX_TAG = 40;
+const DATE = /^\d{4}-\d{2}-\d{2}$/;
+const KEY_OK = (k) => typeof k === 'string' && k.length > 0 && k.length < 300;
+
+// ── The store: crm-<profile>.json ─────────────────────────────────────────
+
+export function emptyCrm() {
+  return { version: 1, settings: { awaitDays: AWAIT_DAYS }, people: {} };
+}
+
+/** Tags as typed, without commas or control characters, once each whatever the case. */
+export function cleanTags(list) {
+  const raw = Array.isArray(list) ? list : typeof list === 'string' ? list.split(',') : [];
+  const seen = new Set();
+  const out = [];
+  for (const t of raw) {
+    const tag = String(t ?? '').replace(/[\u0000-\u001f,]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, MAX_TAG);
+    if (!tag || seen.has(tag.toLowerCase())) continue;
+    seen.add(tag.toLowerCase());
+    out.push(tag);
+    if (out.length >= MAX_TAGS) break;
+  }
+  return out;
+}
+
+/** A real calendar day as YYYY-MM-DD, or null. */
+function cleanDay(s) {
+  if (typeof s !== 'string' || !DATE.test(s)) return null;
+  const t = Date.parse(`${s}T00:00:00Z`);
+  return Number.isNaN(t) || new Date(t).toISOString().slice(0, 10) !== s ? null : s;
+}
+
+/** One person's CRM entry with only what it may hold, or null when there's nothing in it. */
+export function cleanEntry(e) {
+  if (!e || typeof e !== 'object') return null;
+  const out = {};
+  if (STAGE_IDS.has(e.stage)) out.stage = e.stage;
+  const tags = cleanTags(e.tags);
+  if (tags.length) out.tags = tags;
+  if (typeof e.notes === 'string' && e.notes.trim()) out.notes = e.notes.slice(0, MAX_NOTES);
+  const followUp = cleanDay(e.followUp);
+  if (followUp) out.followUp = followUp;
+  if (!Object.keys(out).length) return null;
+  if (typeof e.updatedAt === 'string' && !Number.isNaN(Date.parse(e.updatedAt))) out.updatedAt = e.updatedAt;
+  return out;
+}
+
+const cleanDays = (n) => {
+  const d = Math.round(Number(n));
+  return Number.isFinite(d) && d >= 1 && d <= 365 ? d : AWAIT_DAYS;
+};
+
+/** The whole file, read back: anything that isn't a CRM entry is dropped. */
+export function cleanCrm(raw) {
+  const out = emptyCrm();
+  if (!raw || typeof raw !== 'object') return out;
+  out.settings.awaitDays = cleanDays(raw.settings?.awaitDays);
+  for (const [key, e] of Object.entries(raw.people && typeof raw.people === 'object' ? raw.people : {})) {
+    if (!KEY_OK(key)) continue;
+    const entry = cleanEntry(e);
+    if (entry) out.people[key] = entry;
+  }
+  return out;
+}
+
+/**
+ * One change to the store: { key, set } changes that person's fields (only the
+ * ones sent; null or '' clears one), { settings } the settings. A person left
+ * with nothing is taken out. Returns the new store; the old one isn't touched.
+ */
+export function patchCrm(store, { key, set, settings } = {}, now = Date.now()) {
+  const out = cleanCrm(store);
+  if (settings && typeof settings === 'object' && 'awaitDays' in settings) out.settings.awaitDays = cleanDays(settings.awaitDays);
+  if (KEY_OK(key) && set && typeof set === 'object') {
+    const merged = { ...(out.people[key] || {}) };
+    for (const f of ['stage', 'tags', 'notes', 'followUp']) {
+      if (!(f in set)) continue;
+      if (set[f] == null || set[f] === '' || (Array.isArray(set[f]) && !set[f].length)) delete merged[f];
+      else merged[f] = set[f];
+    }
+    delete merged.updatedAt;
+    const entry = cleanEntry(merged);
+    if (entry) out.people[key] = { ...entry, updatedAt: new Date(now).toISOString() };
+    else delete out.people[key];
+  }
+  return out;
+}
+
+// ── Contacts: everything known about each person ─────────────────────────
+
+/** Today on this computer's calendar, as YYYY-MM-DD (a follow-up date is a day, not a moment). */
+export function localDay(d = new Date()) {
+  const p = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}
+
+const PROFILE = /^https:\/\/(www\.)?linkedin\.com\/in\/[^/?#\s]+$/;
+const slug = (u) => String(u || '').replace(/\/+$/, '').split('/').pop();
+
+/** Who a key is, for showing: their name in the network, else as the export or the sync spelt it, else the end of their link. */
+function nameFor(key, row, names) {
+  if (row?.name) return row.name;
+  if (names[key]) return names[key];
+  if (key.startsWith('name:')) return key.slice(5).replace(/\b\w/g, (c) => c.toUpperCase());
+  return slug(key);
+}
+
+const TIER_ORDER = { S: 0, A: 1, B: 2, C: 3, D: 4 };
+const betterRow = (a, b) => (a.degree ?? 9) < (b.degree ?? 9)
+  || ((a.degree ?? 9) === (b.degree ?? 9) && (TIER_ORDER[a.tier] ?? 9) < (TIER_ORDER[b.tier] ?? 9));
+
+/**
+ * Everyone you've been in touch with, one contact each, and the group
+ * conversations beside them:
+ *
+ *   conversations  the Conversations list (conversationList): 1:1 ones make
+ *                  contacts, groups are returned as they are
+ *   invitations    buildInvitations' records
+ *   network        { degree1, degree2, degree3 } rows, as /api/network sends them
+ *   crm            the store (cleanCrm)
+ *   names          names by key, from the export and the live sync
+ *   also           keys to make a contact for even with nothing on file yet
+ *                  (someone found by search, to add a note to)
+ *
+ * A person the export knows only by name (no link) is joined to the network's
+ * person of that name when only one has it. A contact:
+ *
+ *   { key, name, row, connection, degree, profileUrl, introducers,
+ *     conversations, groups, last, lastFromThem, unread, threadUrl, count,
+ *     theyWrote, kind, invitesIn, invitesOut, request, crm, lastContact }
+ */
+export function buildContacts({ conversations = [], invitations = [], network = {}, crm = emptyCrm(), names = {}, also = [] } = {}) {
+  const degree1 = network.degree1 || [];
+  const degree2 = network.degree2 || [];
+  const rows = [...degree1, ...degree2, ...(network.degree3 || [])];
+  const byKey = new Map();
+  const byName = new Map();
+  for (const r of rows) {
+    const k = keyFor(r);
+    const had = byKey.get(k);
+    if (!had || betterRow(r, had)) byKey.set(k, r);
+  }
+  for (const [k, r] of byKey) {
+    const n = nameKey(r.name);
+    if (n) byName.set(n, byName.has(n) && byName.get(n) !== k ? null : k);
+  }
+  const connected = new Set(degree1.map(keyFor));
+  const routes = routeIndex(degree2);
+  const bridgeById = new Map(degree1.map((r) => [r.id, r]));
+  // A name-only key becomes the network's person of that name, when there's one.
+  const resolve = (k) => (k.startsWith('name:') ? byName.get(k.slice(5)) || k : k);
+
+  const contacts = new Map();
+  const contact = (rawKey) => {
+    const key = resolve(rawKey);
+    let c = contacts.get(key);
+    if (c) return c;
+    const row = byKey.get(key) || null;
+    c = {
+      key,
+      name: nameFor(key, row, names),
+      row,
+      connection: connected.has(key),
+      degree: row?.degree ?? null,
+      profileUrl: PROFILE.test(key) ? key : (row?.profile_url && PROFILE.test(keyFor(row)) ? keyFor(row) : null),
+      introducers: row && row.degree === 2
+        ? [...new Set(routesFor(row, routes, bridgeById).map((x) => x.bridge?.name).filter(Boolean))]
+        : [],
+      conversations: [],
+      groups: [],
+      last: null,
+      lastFromThem: null,
+      unread: null,
+      threadUrl: null,
+      count: 0,
+      theyWrote: false,
+      kind: null,
+      invitesIn: [],
+      invitesOut: [],
+      request: null,
+      crm: crm?.people?.[key] || null,
+      lastContact: null,
+    };
+    contacts.set(key, c);
+    return c;
+  };
+
+  const groups = [];
+  for (const conv of conversations) {
+    if (!conv || !Array.isArray(conv.people)) continue;
+    if (conv.group) {
+      groups.push({ ...conv, people: conv.people.map(resolve) });
+      continue;
+    }
+    if (!conv.people.length) {
+      // Only you wrote, and the export doesn't say to whom: kept as a group-like entry of its own.
+      groups.push({ ...conv, unknown: true });
+      continue;
+    }
+    const c = contact(conv.people[0]);
+    c.conversations.push(conv);
+    c.count += conv.count || 0;
+    if (conv.lastFromThem === true || (conv.count != null && conv.mine != null && conv.count > conv.mine)) c.theyWrote = true;
+    if (conv.last && (!c.last || conv.last >= c.last)) {
+      c.last = conv.last;
+      c.lastFromThem = conv.lastFromThem;
+      c.unread = conv.unread;
+      c.threadUrl = conv.threadUrl || c.threadUrl;
+    } else if (!c.last && !conv.last) {
+      c.threadUrl = conv.threadUrl || c.threadUrl;
+    }
+  }
+  for (const c of contacts.values()) {
+    c.conversations.sort((a, b) => (b.last || 0) - (a.last || 0));
+    // An advert or an InMail only when every conversation with them is one.
+    const kinds = new Set(c.conversations.map((x) => x.kind || null));
+    c.kind = kinds.size === 1 ? [...kinds][0] : null;
+  }
+  for (const g of groups) for (const k of g.people) contacts.get(k)?.groups.push(g.id);
+
+  for (const inv of invitations) {
+    if (!inv?.key) continue;
+    const c = contact(inv.key);
+    if (inv.name && !c.row && !names[c.key]) c.name = inv.name;
+    (inv.dir === 'in' ? c.invitesIn : c.invitesOut).push(inv);
+  }
+
+  // Requests the app tracks: the Outlink queue's "Mark sent", once per person.
+  for (const r of rows) {
+    const sent = r.outreach_status === 'sent' || r.outreach_status === 'accepted' || r.unlock_status === 'pending';
+    if (!sent) continue;
+    const c = contact(keyFor(r));
+    const status = c.connection || r.outreach_status === 'accepted' ? 'accepted' : 'pending';
+    if (!c.request || status === 'accepted') c.request = { status };
+  }
+
+  for (const key of Object.keys(crm?.people || {})) contact(key);
+  for (const key of also) if (KEY_OK(key)) contact(key);
+
+  for (const c of contacts.values()) {
+    const times = [c.last, ...c.invitesIn.map((i) => i.t), ...c.invitesOut.map((i) => i.t)].filter(Boolean);
+    c.lastContact = times.length ? Math.max(...times) : null;
+  }
+  return { contacts, groups };
+}
+
+/** Where a contact seems to be, from what happened, for when you haven't set a stage. */
+export function suggestedStage(c) {
+  if (c.theyWrote) return 'replied';
+  if (c.conversations.length || c.invitesOut.length || c.request) return 'contacted';
+  return 'new';
+}
+
+const isAdvert = (c) => c.kind === 'sponsored';
+
+/** Waiting on you: they wrote last, or there's something unread. Unread first, then the newest. */
+export function inboxOf(contacts) {
+  return [...contacts].filter((c) => !isAdvert(c) && (c.lastFromThem === true || c.unread > 0))
+    .sort((a, b) => (b.unread > 0) - (a.unread > 0) || (b.last || 0) - (a.last || 0));
+}
+
+/**
+ * Awaiting reply: you wrote last, in a 1:1 conversation, and `days` or more
+ * have gone by with nothing back, as of `asOf` (the newest thing the data
+ * knows, so an older export reads as it was). Each with `waited` (days).
+ */
+export function awaitingOf(contacts, asOf, days = AWAIT_DAYS) {
+  const out = [];
+  for (const c of contacts) {
+    if (isAdvert(c) || c.lastFromThem !== false || !c.last) continue;
+    const waited = Math.floor((asOf - c.last) / DAY);
+    if (waited >= days) out.push({ contact: c, waited });
+  }
+  return out.sort((a, b) => a.waited - b.waited);
+}
+
+/** Follow-ups due: a next follow-up date of today or before. Oldest first. */
+export function followUpsDue(contacts, today = localDay()) {
+  return [...contacts].filter((c) => c.crm?.followUp && c.crm.followUp <= today)
+    .sort((a, b) => a.crm.followUp.localeCompare(b.crm.followUp));
+}
+
+/** The pipeline: people you've given a stage, by stage, most recently in touch first. */
+export function pipelineOf(contacts) {
+  const out = Object.fromEntries(STAGES.map((s) => [s.id, []]));
+  for (const c of contacts) if (c.crm?.stage) out[c.crm.stage].push(c);
+  for (const list of Object.values(out)) list.sort((a, b) => (b.lastContact || 0) - (a.lastContact || 0));
+  return out;
+}
+
+/**
+ * Sent: what went out from you, per person, newest first.
+ *   invite    a connection request (Invitations.csv, OUTGOING): accepted once
+ *             they're a connection, pending until then
+ *   request   one the app tracked (Mark sent): the same
+ *   awaiting  a message with no reply for `days` or more (awaitingOf)
+ * Each: { contact, t, items: [{ type, t?, status?, waited?, id? }] }.
+ */
+export function sentOf(contacts, asOf, days = AWAIT_DAYS) {
+  const list = [...contacts];
+  const waiting = new Map(awaitingOf(list, asOf, days).map((a) => [a.contact.key, a.waited]));
+  const out = [];
+  for (const c of list) {
+    const items = [];
+    for (const inv of c.invitesOut) items.push({ type: 'invite', id: inv.id, t: inv.t, status: c.connection ? 'accepted' : 'pending' });
+    if (c.request) items.push({ type: 'request', status: c.request.status });
+    if (waiting.has(c.key)) items.push({ type: 'awaiting', t: c.last, waited: waiting.get(c.key) });
+    if (!items.length) continue;
+    out.push({ contact: c, items, t: Math.max(0, ...items.map((i) => i.t || 0)) });
+  }
+  return out.sort((a, b) => b.t - a.t);
+}
+
+/** Received: requests to you from people who aren't connections yet (so you haven't accepted them). Newest first. */
+export function receivedOf(contacts) {
+  const out = [];
+  for (const c of contacts) {
+    if (c.connection || !c.invitesIn.length) continue;
+    out.push({ contact: c, t: Math.max(0, ...c.invitesIn.map((i) => i.t || 0)) });
+  }
+  return out.sort((a, b) => b.t - a.t);
+}
+
+/**
+ * Search across names, companies, roles, tags and notes, and what was said
+ * when the messages are kept: `said` is the set of conversation ids whose
+ * kept messages match (GET /api/social/messages?q=).
+ */
+export function matchesContact(c, q, said = null) {
+  const words = String(q || '').trim().toLowerCase();
+  if (!words) return true;
+  const hay = [c.name, c.row?.company, c.row?.role, c.row?.headline, ...(c.crm?.tags || []), c.crm?.notes]
+    .filter(Boolean).join('\n').toLowerCase();
+  return hay.includes(words) || (!!said && c.conversations.some((conv) => said.has(conv.id)));
+}
+
+// ── The CSV export ───────────────────────────────────────────────────────
+
+/**
+ * One cell. Quoted when it holds a comma, a quote or a line break; and a
+ * leading =, +, - or @ gets a ' in front, so a spreadsheet shows it as text
+ * instead of running it as a formula (a note or a name is written by someone).
+ */
+export function csvCell(v) {
+  let s = v == null ? '' : String(v);
+  if (/^[=+\-@\t\r]/.test(s)) s = `'${s}`;
+  return /[",\r\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+}
+
+const isoDay = (t) => (t ? new Date(t).toISOString().slice(0, 10) : '');
+
+export const CSV_COLUMNS = ['Name', 'Company', 'Profile', 'Connection', 'Stage', 'Tags', 'Last contact', 'Who wrote last', 'Next follow-up', 'Notes'];
+
+/** The CRM table as a CSV file's text: one row per contact, as Excel and Numbers read it (a BOM, CRLF). */
+export function crmCsv(contacts) {
+  const lines = [CSV_COLUMNS.map(csvCell).join(',')];
+  for (const c of contacts) {
+    lines.push([
+      c.name,
+      c.row?.company || '',
+      c.profileUrl || '',
+      c.connection ? 'Yes' : 'No',
+      stageLabel(c.crm?.stage),
+      (c.crm?.tags || []).join('; '),
+      isoDay(c.lastContact),
+      c.lastFromThem == null ? '' : c.lastFromThem ? 'Them' : 'You',
+      c.crm?.followUp || '',
+      c.crm?.notes || '',
+    ].map(csvCell).join(','));
+  }
+  return `${lines.join('\r\n')}\r\n`;
+}

package/.next/standalone/lib/social-store.js

@@ -4,13 +4,18 @@
 //                                   messaged, when, who wrote last, the list of
 //                                   conversations. Never any words.
 //   social-messages-<profile>.json  the messages themselves, only while Keep my
-//                                   messages is on (app/api/social/messages).
+//                                   messages is on (app/api/social/messages),
+//                                   and the notes sent with requests, likewise.
+//   crm-<profile>.json              your own CRM: each person's stage, tags,
+//                                   notes and next follow-up (app/api/social/crm,
+//                                   lib/social-crm.js). Always kept: you wrote
+//                                   it. Forget it offers to delete it, asking
+//                                   separately, so notes aren't lost by accident.
 //
 // Two files so that turning Keep my messages off, or Forget it, deletes the
 // words by deleting one file, and so the everyday file the Galaxy and the
-// Social tab read stays small however many messages there are. Neither is in
-// "Save a copy of my network": that carries an allow-list of files
-// (lib/data-folder.js TRAVELLING_FILES) and these aren't on it.
+// Social tab read stays small however many messages there are. "Save a copy of my network" carries
+// them when its Social box is ticked (lib/data-folder.js SOCIAL_FILE).
 
 import { readFileSync, writeFileSync, renameSync, rmSync, statSync } from 'node:fs';
 import path from 'node:path';
@@ -30,6 +35,7 @@ export function socialFiles() {
     profileId: me.id,
     social: path.join(dir, `social-${me.id}.json`),
     messages,
+    crm: path.join(dir, `crm-${me.id}.json`),
     // An import's messages arrive in parts (each request stays under the 10 MB
     // middleware reads); they gather here and replace `messages` at the end.
     incoming: `${messages}.incoming`,
@@ -48,17 +54,18 @@ export function writeJsonAtomic(file, value) {
   if (cache.file === file) cache.file = null;
 }
 
-/** The kept messages and their live-sync previews, or empty ones. */
+/** The kept messages, their live-sync previews and the requests' notes, or empty ones. */
 export function readMessages(file) {
   // Kept in memory while the file is unchanged: a long history is read once,
   // not on every page of a thread or every letter typed in the search box.
   let st;
-  try { st = statSync(file); } catch { return { threads: {}, previews: {} }; }
+  try { st = statSync(file); } catch { return { threads: {}, previews: {}, invites: {} }; }
   if (cache.file === file && cache.mtimeMs === st.mtimeMs && cache.size === st.size) return cache.data;
   const raw = readJson(file, {});
   const data = {
     threads: raw?.threads && typeof raw.threads === 'object' ? raw.threads : {},
     previews: raw?.previews && typeof raw.previews === 'object' ? raw.previews : {},
+    invites: raw?.invites && typeof raw.invites === 'object' ? raw.invites : {},
   };
   Object.assign(cache, { file, mtimeMs: st.mtimeMs, size: st.size, data });
   return data;

package/.next/standalone/lib/tier-grid.js

@@ -0,0 +1,99 @@
+// The Filters panel's grid: five tiers down, six degrees across, the same in
+// Network Circle and in Degrees.
+//
+// Blake, 2026-10-02: "keeping the tiers as is but enlarging them and having 6
+// dots to let the user tap on to toggle or not if they want specific degrees
+// showing for whatever tier … it will be universal for both".
+//
+// A grid is { hidden: [tiers switched off], degrees: { S: [1, 2], … } }: a tier
+// row switches on and off as it always did, and remembers which degrees it
+// shows while it's off. Counts are { S: { 1: n, 2: n, … }, … }: how many people
+// there are at each tier and degree, so a dot with nobody behind it can't be
+// tapped, and the last people on screen can't be switched off.
+
+export const TIERS = ['S', 'A', 'B', 'C', 'D'];
+export const GRID_DEGREES = [1, 2, 3, 4, 5, 6];
+
+const tierOf = (tier) => (TIERS.includes(tier) ? tier : 'D');   // no tier: with D, as the views draw it
+
+export const makeGrid = (degrees = GRID_DEGREES) => ({
+  hidden: [],
+  degrees: Object.fromEntries(TIERS.map((t) => [t, degrees.slice()])),
+});
+
+/** Network Circle starts with your own connections; you pick the rest. */
+export const NETWORK_GRID = Object.freeze(makeGrid([1]));
+/** Degrees starts with everything it has. */
+export const DEGREES_GRID = Object.freeze(makeGrid());
+
+/** Is someone of this tier, at this degree, on screen? */
+export function shows(grid, tier, degree) {
+  const t = tierOf(tier);
+  return !grid.hidden.includes(t) && grid.degrees[t].includes(degree);
+}
+
+const countAt = (counts, tier, degree) => counts?.[tier]?.[degree] || 0;
+
+/** How many people one tier is showing. */
+export function showingIn(grid, counts, tier) {
+  if (grid.hidden.includes(tier)) return 0;
+  return grid.degrees[tier].reduce((n, d) => n + countAt(counts, tier, d), 0);
+}
+
+/** How many people the whole grid is showing. */
+export const showing = (grid, counts) => TIERS.reduce((n, t) => n + showingIn(grid, counts, t), 0);
+
+// A change that would leave nobody on screen isn't made.
+const keep = (grid, next, counts) => (counts && showing(next, counts) === 0 ? grid : next);
+
+/** One dot: that degree, for that tier. Tapping a dot in a tier that's off switches the tier on with it. */
+export function toggleCell(grid, tier, degree, counts) {
+  const has = grid.degrees[tier].includes(degree);
+  const off = grid.hidden.includes(tier);
+  const degrees = off || !has
+    ? [...new Set([...grid.degrees[tier], degree])].sort((a, b) => a - b)
+    : grid.degrees[tier].filter((d) => d !== degree);
+  return keep(grid, {
+    hidden: off ? grid.hidden.filter((t) => t !== tier) : grid.hidden,
+    degrees: { ...grid.degrees, [tier]: degrees },
+  }, counts);
+}
+
+/** A whole tier, off or back on with the degrees it had. */
+export function toggleTier(grid, tier, counts) {
+  if (!grid.hidden.includes(tier)) return keep(grid, { ...grid, hidden: [...grid.hidden, tier] }, counts);
+  // Back on with nothing to show would look broken: give it what the others show.
+  const own = grid.degrees[tier];
+  const others = [...new Set(TIERS.flatMap((t) => (t === tier ? [] : grid.degrees[t])))].sort((a, b) => a - b);
+  return {
+    hidden: grid.hidden.filter((t) => t !== tier),
+    degrees: own.length ? grid.degrees : { ...grid.degrees, [tier]: others.length ? others : [1] },
+  };
+}
+
+/** A whole degree: off if every tier with people there is showing it, otherwise on for all of them. */
+export function toggleDegree(grid, degree, counts) {
+  const tiers = TIERS.filter((t) => !grid.hidden.includes(t) && (!counts || countAt(counts, t, degree) > 0));
+  if (!tiers.length) return grid;
+  const allOn = tiers.every((t) => grid.degrees[t].includes(degree));
+  const degrees = { ...grid.degrees };
+  for (const t of tiers) {
+    degrees[t] = allOn ? degrees[t].filter((d) => d !== degree) : [...new Set([...degrees[t], degree])].sort((a, b) => a - b);
+  }
+  return keep(grid, { ...grid, degrees }, counts);
+}
+
+/** Every tier back on, each with the degrees it had. */
+export const showAllTiers = (grid) => (grid.hidden.length ? { ...grid, hidden: [] } : grid);
+
+/** People by tier and degree, for the dots: `byDegree` is { 1: rows, 2: rows, … }. */
+export function gridCounts(byDegree = {}) {
+  const counts = Object.fromEntries(TIERS.map((t) => [t, {}]));
+  for (const [degree, rows] of Object.entries(byDegree)) {
+    for (const row of rows || []) {
+      const t = tierOf(row?.tier);
+      counts[t][degree] = (counts[t][degree] || 0) + 1;
+    }
+  }
+  return counts;
+}