six-degrees 0.4.11 → 0.5.0

package/.next/standalone/CHANGELOG.md

@@ -6,6 +6,193 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.0] - 2026-10-02
+
+### Added
+- **Rank titles your way** (Settings → Scores → Titles). Set how much each kind of title counts, out
+  of 10, or start from a preset: Founders first, Investors, or A role I'm looking for. Add the roles
+  you're after ("account executive", "head of growth", "recruiter") with their own points, and
+  everyone whose title has those words rises, whatever their level: for outbound to one role, or
+  hiring for it. Saving rescores everyone and says how many people changed tier, and a card's score
+  says "your ranking" where it moved a title. Nothing set scores exactly as before.
+
+### Changed
+- **The Scan page is a launch, not a manual.** It opens with what the scanner is and what it never does
+  (never posts or messages anyone, never sees your password, nothing leaves this Mac, stops when you
+  say), then the four steps on a rail: Get ready, Sign in, Who you know, Who they know. The one
+  you're on pulses, with one big button that does it and how long it takes; any other opens with a
+  tap. While it runs, "Your scanner is working" and Stop sit right under the step. How many people
+  this round and who first are beside the radar; the daily budget, how much of each list, the hidden
+  window, retrying hidden lists and paused lists are in Fine-tune, closed until you want them. The
+  log is one tap away, and opens by itself when a run stops badly. Scan has the same header as every
+  page now.
+- **Paths reads like Network Circle.** Its notch is now Map and Companies: companies count for more
+  than industries, and an industry opens from a company's card (its industry is a link there). Whether
+  the map's bubbles are companies or your connections (what was the People tab) is a switch at the
+  top of the Filters panel. Filters use the same tiers × degrees grid as Network Circle. Colour is by
+  sector or by **Heat**: for companies, how strong your people there are (the average power of the
+  five strongest); for people, how strong their cluster is, person for person; size still says how
+  many. And **Physics**: switch it to Live to drag bubbles (the ones joined to them follow) and change
+  Spread, Pull to their group and Pull along lines. Still, as before, is the default. Old links to
+  the People or Industries tab still land on the map.
+- **Heat: power as a thermal map.** A new Colour by in Network Circle's Physics: every dot coloured
+  from cold violet through red and orange to white hot by where their power score ranks among the
+  people showing, with a soft glow behind the hotter ones that pools where powerful people cluster,
+  like a thermal camera. Works with every layout, the replay and the filter grid.
+- **Separation all the way right counts every mutual, scanned or not.** It aims at whoever you share
+  the most mutual connections with, even when most of them are in circles you haven't scanned: an
+  unscanned mutual is still a likely introduction, so it no longer holds someone back. The ones the
+  app can draw are lines as before; the rest are grey dots, each with a faint line in, with "+37 more
+  mutuals, in circles not scanned yet". The person glows less the less of it is scanned. The Next
+  names are in the same order and say their mutual counts. Narrow the tiers (S only, say) first to
+  aim at the strongest.
+- **The right panel follows the circle you're in.** Open someone's circle in Bridge Chains and the
+  panel is about them: how many people are in their circle, tier chips to see just one tier, a
+  search inside it, the people you added from it (with Scan… for the ones ready), then everyone
+  else in it, strongest first. Click anyone for their card.
+- **Orbit is a layout of the Galaxy now**, in Physics next to Rings and Clusters, not a separate
+  view: every tier held on its own orbit, S nearest you, and each connection's circle tucked in
+  behind them. It's still the Galaxy, so you can drag dots and move every slider on it.
+- **Light up a branch on hover starts off.** It dimmed and relit thousands of dots on every hover,
+  which flickered; it's still in Physics if you want it, and moving from one dot to the next no
+  longer flashes the whole Galaxy in between.
+- **Social is part of Outlink.** Outlink has the same header as every page, and its views sit in
+  the notch: Circles, To add, Pending, and Messages & follow-ups, which is the whole Social tab (your
+  LinkedIn export, the live messages sync, the CRM with its inbox, follow-ups, pipeline, sent and
+  received). Adding people and keeping track of them are now one place. The Social tab is gone from
+  the header, and old links to it land on Messages & follow-ups.
+- **Notifications open.** Click one and it takes over the right panel with the detail: who it is
+  about, their tier and score, who you met them through, and, for an S or A, that they're a
+  valuable person to know; with buttons to open their card, their circle in Bridge Chains, or
+  them in Separation. A notification naming several people lists them all.
+- **New notifications:** someone you met through a bridge added you back ("Ana added you back,
+  through Yuki"); a circle scan found people at top companies (a company score of 8 or more), named
+  in one notification; and a scan finished ("Scan done: Yuki's circle", "Check for new: done").
+  Accepted requests and high-value new connections now say who they are about, and older ones are
+  matched by the name in their title.
+- **Paths has the same header as the map.** The app's tabs stay at the top, with Paths lit, and Map,
+  People, Industries and Companies sit in the notch under them, as the map page's views do; a tab
+  for Network Circle, Degrees or Separation takes you straight to it. Paths' filters moved into a
+  Filters panel on the left, like the map page's, with new ways to read the map: what a bubble's
+  size means (your people there, the S and A among them, or the ones you already know; on People,
+  cluster value, size or S tier) and which names show (the biggest, all, or none).
+- **All the way to easy, Separation aims at whoever the most of your connections lead to**, with
+  every one of those lines drawn, the strongest first among equals; the "Next" names are the
+  runners-up by the same measure. It used to aim at the top of the list, which could be someone
+  with many mutual connections by LinkedIn's count but only one the app could draw.
+- **The Scan page has a radar, and a speed: Slow, Medium or Fast.** Mapping the 2nd degree starts
+  from a round Scan button in the middle of a radar: its sweep turns while a scan runs, and the
+  ring round it fills with today's searches against your budget. Beside it, three speeds. Fast is
+  how the scanner has always run, and nothing is faster; Medium waits 45 seconds before each page
+  of results and 3 minutes after every 10, Slow 90 seconds and 5 minutes, and both keep profiles
+  further apart (90 and 120 seconds). Each says about how many searches an hour it makes and how
+  long the rest of today's budget would take. The daily budget stays the cap at every speed:
+  slower spreads it out, it doesn't shrink it. The speed is saved with the budget and the scanner
+  says which it is using at the start of every run; the Scan page's time estimates follow it.
+- **Scores moved into Settings.** Your field, how tiers are graded and every company's score are a
+  Scores section in Settings (the gear), and the Scores tab is gone from the header. Old links to
+  the Scores tab land in the same place in Settings.
+- **Profile has Insights.** An Insights button beside Profile shows network health: how much of
+  your 2nd degree you reach two or more ways, the effective reach of your connections, and the
+  connections who reach the most people no one else does. It was at the top of the Scores tab.
+- **Paths → People.** A new view beside the company map, drawn the same way but with your
+  connections as the bubbles: each is sized by the value of the cluster behind them (S tier counts
+  3, A tier 2, everyone else 1; or by cluster size, or by S tier inside), coloured by their sector
+  and grouped like the companies. A white centre is the share of their cluster you can only reach
+  through them, a gold ring means S-tier people inside, and a line joins two connections whose
+  clusters share people. Point at someone for their numbers and how their cluster compares to the
+  rest you've scanned; click to open it in Bridge Chains. Shows the connections you've scanned,
+  or all of them, with the ones not scanned yet as small grey dots.
+- **Separation's map draws connections as pills and people as cards** on a computer (a phone keeps
+  the dots). Each connection shows their initials, tier and what they are to the people on the
+  map: the only door to someone, the best way in for some, or only another way in; the ones with
+  a solid line are lit. Each person is a card with rank, role, score and how many ways in. With
+  the slider all the way to easy, the one person becomes a large card with LinkedIn's mutual
+  count and how many of those are drawn. Everything still glides as the slider moves.
+- **Separation's list is a ledger.** A title bar says how many are shown and that the order
+  follows the slider. The way in shows the connection's face with "only way in" or how many more
+  ways there are under it, a new column shows how rare the way in is as a bar (full and cyan for
+  one door, short and orange for the warmest), and the power score sits beside its bar.
+- **Separation is a tab of its own**, beside Degrees in the header, instead of a view inside
+  Degrees. It uses the same Filters grid as Degrees. Degrees keeps Bridge Chains, Pyramid and List.
+- **Separation has a slider.** One slider reorders everyone as you drag it: the rarest ways in
+  at one end (strong people only one of your connections knows), the easiest at the other
+  (strong people you share the most mutual connections with), and each person's own score alone
+  in the middle, as the list has always been. A line under it says in words what it is
+  surfacing. It only reorders: scores, tiers and ranks stay as they are, and it claims no odds.
+  Double-click the slider, or tap 50, to go back to the middle. It replaces the Power / Ways in
+  switch. The tier chips and the rarity chips ("Only show") sit in the same card.
+- **Separation's map follows the slider, and glides.** From the rare end to the middle it fans out
+  to ten people, each with the one or two doors that lead to them. Towards the easy end it
+  closes in on fewer people, and at the end on one: the person you're aiming at, with rings
+  round them and every connection of yours who leads to them drawn in, the top-scored one solid.
+  As the slider moves, people, connections and lines slide to their new places and newcomers
+  fade in (still, with Reduce Motion on). Pick anyone in the list, or one of the "Next" names
+  under the map, to aim at them instead. Beside each name it says how many mutual connections
+  lead to them: "only way in", "3 ways in", or, where LinkedIn's own count is higher than the
+  connections the app can draw, "37 mutuals · 6 mapped".
+- **Path, in Separation.** A Path button beside the tier chips narrows everyone to one sector or
+  one company. The picker opens under the button with the sectors (inferred, as in Paths), the
+  biggest companies and a box to type in, and goes away once you've picked; the button then
+  shows your pick with a × to clear it.
+- **Separation's heading no longer sits under the notch.**
+- **One filter for tiers and degrees, the same in Network Circle and in Degrees.** The Filters
+  panel shows the five tiers as bigger rows, each with six dots, one for each degree. Tap a tier
+  to hide or show it, as before. Tap a dot to show or hide that degree for that tier alone:
+  S tier at 2nd degree without everyone else's, say. Tap a number at the top to switch a degree
+  for every tier at once. A dot with nobody behind it is faint and can't be tapped, each row
+  says how many people it is showing, and the last people on screen can't be switched off.
+  Network Circle starts with your own connections; Degrees starts with everything. In Degrees
+  the rows used to pick one bridge tier at a time; now 1st degree is your bridges and 2nd is
+  the people in their circles, each by their own tier.
+- **The Galaxy's physics is the main thing in Network Circle's Filters panel.** The sliders,
+  layouts, colours, find and replay sit straight in the panel under the tiers, always on, with
+  no switch to turn on first and no "experimental" box. With no slider moved the Galaxy is laid
+  out as before; pointing at a dot now lights up its branch unless you turn that off.
+- **Pyramid and List left Network Circle.** Its views are the Galaxy and Orbit. Pyramid and List
+  stay in Degrees.
+- **An opened circle shows the chains that lead on from it.** Anyone you added from that circle
+  and then scanned keeps their dot in the circle, and the cluster their scan formed sits outside
+  it, joined to that dot by a line, so you can see where each path came from. Inside a cluster,
+  anyone you added and scanned in turn has their own dot marked and a line on to their cluster,
+  for as far as your scans reach. Every dot in a cluster is joined to its middle by a faint line.
+  Each cluster says whose circle it is, how many are in it and which degree that is. Point at
+  one and the way back to the middle lights up; click and it opens with the whole trail. The
+  people you added sit together on the side the chains lead off to, their names taking turns
+  above and below so they don't overlap, and the view zooms to fit when it opens.
+- **Bridge Chains shows the bridges you connected with yourself.** Someone you met through a
+  bridge's circle is a link in that bridge's chain, not a bridge of their own: they're inside its
+  circle.
+- **A bridge's ring now counts the people you added through it.** The ring sits tight on the
+  dot, with one bar for each person: orange once they've been scanned and have a cluster of
+  their own, green while they're ready for a scan. A small green number at the top right says
+  how many are ready, in place of the "ready" label. How much of a bridge's own list is scanned
+  is in its tooltip.
+- **A crowded Bridge Chains is easier to read.** When your bridges need more than one ring, the
+  rings sit further apart, each with its own guide line, and the counts under each name wait
+  until you point at the bridge.
+- **Orbit moved to Network Circle.** It shows the size of every circle at once, which is a
+  picture of the network, not a way to follow a chain. The corner switch in Degrees is gone.
+- **Views are in the notch, under the tabs.** Galaxy, Orbit, Pyramid and List in Network Circle,
+  and Bridge Chains, Separation, Pyramid and List in Degrees, switch from the notch that hangs
+  under the top tabs, instead of a list at the top of the Filters panel. A scan's progress
+  shows in the same notch, beside them. The Filters panel now only filters.
+
+### Fixed
+- The scanner's log, shown on the Scan page, says "scanning" throughout; a few lines still said the
+  old word.
+- The "Scanning…" dot in the right panel pulses again; the animation it named was never defined.
+- **Separation's map lines now meet every box.** Each connection sits level with the people it
+  leads to, so a connection with one person is on that person's row and the line between them runs
+  straight; lines start and end exactly on the pill and the card, with a small dot where they plug in.
+- **"Hide the Chrome window while scanning" did nothing for scans started on the Scan page.**
+  Its own buttons (Scan, Check for new, Auto scan and the rest) sent their request without the
+  setting, so Chrome opened anyway; only scans started from a person's card or Resume were hidden.
+  Every scan start now goes through one place that adds it.
+- **"Only way in" could show beside someone with two ways in drawn.** Rarity trusted the mutual
+  count a scan saved even when the app had since found them through more of your connections
+  than that. It now takes whichever is larger.
+
 ## [0.4.11] - 2026-09-29
 
 ### Added

package/.next/standalone/app/api/ingest/route.js

@@ -2,6 +2,7 @@ import { db as supabase } from '../../../lib/db';
 import { uniqueByProfile, splitAlreadyConnected, toIsoDate, refreshNotifications, mutualCountOf } from '../../../lib/ingest';
 import { tiePairs } from '../../../lib/ties';
 import { promoteToFirstDegree } from '../../../lib/promote';
+import { addedBackNotification, topCompanyNotification } from '../../../lib/notifications';
 import { localPhoto } from '../../../lib/photos';
 
 function parseHeadline(h) {
@@ -113,6 +114,8 @@ export async function POST(request) {
     const newRecords = records.filter(r => !existingUrls.has(r.profile_url));
     const existingRecords = records.filter(r => existingUrls.has(r.profile_url));
     let promoted = 0;
+    // Who was promoted, and through whom, for an "added you back" notification once they're rescored.
+    const addedBack = [];
 
     // Someone you met through a bridge and have now actually connected with.
     //
@@ -144,7 +147,7 @@ export async function POST(request) {
             ...(rec.profile_image_url ? { profile_image_url: rec.profile_image_url } : {}),
           },
         });
-        if (res.promoted) promoted += 1;
+        if (res.promoted) { promoted += 1; addedBack.push(res); }
       }
     }
 
@@ -240,6 +243,41 @@ export async function POST(request) {
       } catch (e) { /* notifications are optional */ }
     }
 
+    // A circle scan that found people at top companies: one notification naming them (lib/notifications.js).
+    if (degree === 2 && bridgeId && newRecords.length) {
+      try {
+        const found = [];
+        const urls = newRecords.map((r) => r.profile_url).filter(Boolean);
+        for (let i = 0; i < urls.length; i += 100) {
+          let q = supabase.from('linkedin_connections').select('id, name, company, company_prestige_score, power_score, tier')
+            .in('profile_url', urls.slice(i, i + 100)).eq('source_connection_id', bridgeId);
+          if (userId) q = q.eq('user_id', userId);
+          const { data } = await q;
+          found.push(...(data || []));
+        }
+        const { data: via } = await supabase.from('linkedin_connections').select('id, name').eq('id', bridgeId).single();
+        const note = topCompanyNotification({ people: found, via, userId });
+        if (note) await supabase.from('notifications').insert([note]);
+      } catch (e) { /* notifications are optional */ }
+    }
+
+    // Someone you met through a bridge who is now a connection: "added you back, through …".
+    if (addedBack.length) {
+      try {
+        const rows = [];
+        for (const res of addedBack.slice(0, 10)) {
+          const { data: person } = await supabase.from('linkedin_connections')
+            .select('id, name, tier, power_score, headline, unlocked_from_bridge_id').eq('id', res.id).single();
+          if (!person) continue;
+          const viaId = res.originId ?? person.unlocked_from_bridge_id;
+          const via = viaId != null ? { id: viaId, name: res.originName || null } : null;
+          const note = addedBackNotification({ person, via, userId });
+          if (note) rows.push(note);
+        }
+        if (rows.length) await supabase.from('notifications').insert(rows);
+      } catch (e) { /* notifications are optional */ }
+    }
+
     // Auto-detect accepted pending requests: if a pending person just showed up as d1
     if (degree === 1 && records.length > 0) {
       try {
@@ -286,6 +324,7 @@ export async function POST(request) {
               title: `${p.name} accepted! +${XP_ACCEPT[p.tier] || 5} XP`,
               message: `${p.tier}-Tier connection — bridge their cluster to reach D3`,
               icon: '🤝',
+              data: { personId: p.id, viaId: p.source_connection_id ?? null, tier: p.tier ?? null },
             }))
           ).catch(() => {});
         }

package/.next/standalone/app/api/scraper/route.js

@@ -7,6 +7,8 @@ import { scanProgress } from '../../../lib/scan-progress';
 import { linkedinState, writeLimits, liftCooldown } from '../../../lib/linkedin-limits';
 import { pausedList, readProgress, readUnclear } from '../../../lib/paused';
 import { getDb } from '../../../lib/db-client';
+import { db as notesDb } from '../../../lib/db';
+import { scanDoneNotification } from '../../../lib/notifications';
 import { registerScanState } from '../../../lib/scan-state';
 import { pendingImport } from '../../../lib/data-import';
 import { waitingPhotoCount } from '../../../lib/photos';
@@ -540,7 +542,7 @@ export async function POST(request) {
 
   // The two settings a person changes here. Neither starts anything.
   if (action === 'set-limits') {
-    const limits = writeLimits(dataDir(), { daily: body.daily, monthly: body.monthly, profiles: body.profiles });
+    const limits = writeLimits(dataDir(), { daily: body.daily, monthly: body.monthly, profiles: body.profiles, pace: body.pace });
     return Response.json({ ok: true, limits });
   }
   if (action === 'lift-cooldown') {
@@ -712,6 +714,7 @@ export async function POST(request) {
       const reason = state.stderrTail.filter((l) => !/Warning|warnings\.warn\(/.test(l)).slice(-6);
       state.failure = reason.length ? reason : null;
     }
+    const stopped = state.stopping;
     push(state.stopping ? 'Stopped.' : code === 0 ? 'Finished.' : `Stopped (exit ${code}).`);
     state.stopping = false;
     state.running = false;
@@ -721,6 +724,9 @@ export async function POST(request) {
     state.recent = [{
       action: state.action, target: state.target, startedAt: state.startedAt, exitCode: code, failure: state.failure,
     }, ...state.recent].slice(0, 5);
+    // A scan that finished leaves a notification ("Scan done: …"); a stop or a failure doesn't.
+    const done = scanDoneNotification({ action: state.action, target: state.target, exitCode: code, stopped, log: state.log.slice(-12), userId: profileId || null });
+    if (done) Promise.resolve(notesDb.from('notifications').insert([done])).catch(() => {});
     // A setup's private folder (the download and what was unpacked from it).
     if (cleanup) {
       try { cleanup(); } catch { /* swept at the next setup (sweepSetupLeftovers) */ }

package/.next/standalone/app/api/settings/sector-preview/route.js

@@ -1,5 +1,5 @@
 import { getDb } from '../../../../lib/db-client';
-import { companyOverrides, readForScoring, scoringRows, sectorFocusOf, tierScaleOf } from '../../../../lib/rpc';
+import { companyOverrides, readForScoring, scoringRows, sectorFocusOf, tierScaleOf, titleRankingOf } from '../../../../lib/rpc';
 import { parseSectorFocus, previewSectorFocus } from '../../../../lib/sector-focus';
 
 // Scores → Your sector, before you save: what a sector focus would change,
@@ -32,6 +32,7 @@ export async function POST(request) {
       from: sectorFocusOf(db),
       to,
       tierScale: tierScaleOf(db),
+      titles: titleRankingOf(db),
     }));
   } catch (err) {
     return Response.json({ error: err.message }, { status: 500 });

package/.next/standalone/app/components/AppTabs.js

@@ -0,0 +1,59 @@
+'use client';
+
+// The app's tabs, the same on every page (Blake, 2026-10-02: "for paths we
+// need a notch for it so the tabs are visible and continuity is there").
+// Network Circle, Degrees and Separation are views of the map page: there they
+// switch in place (onMode); anywhere else they are links back to it with the
+// tab named (/?mode=…). A page's own sub-tabs go in the notch under this row
+// (lib/island.js setNotchTabs), which looks for #main-tabs to hang from.
+
+import Link from 'next/link';
+import { IS_DEMO } from '../../lib/demo';
+
+const MODES = [
+  { key: 'network', label: 'Network Circle', short: 'Circle', on: { background: '#fff', color: '#000' }, off: { background: 'transparent', color: '#888' } },
+  { key: 'degrees', label: 'Degrees', on: { background: 'linear-gradient(135deg, #FFD700, #FF6B35)', color: '#000' }, off: { background: 'rgba(255,255,255,0.12)', color: '#fff' } },
+  { key: 'separation', label: 'Separation', on: { background: 'linear-gradient(135deg, #00E5FF, #FFD700 55%, #FF7043)', color: '#000' }, off: { background: 'rgba(255,255,255,0.12)', color: '#fff' } },
+];
+const PAGES = [
+  { key: 'paths', href: '/paths', label: 'Paths', color: '#00ff88', on: 'linear-gradient(135deg, #00ff88, #3498DB)', demo: true },
+  // Social is part of Outlink now (Messages & follow-ups); /social forwards there.
+  { key: 'outlink', href: '/queue', label: 'Outlink', color: '#FF6B35', on: 'linear-gradient(135deg, #FF6B35, #FFD700)', own: true },
+  { key: 'scan', href: '/setup', label: 'Scan', color: '#666', on: 'linear-gradient(135deg, #00ff88, #1abc9c)', own: true },
+];
+
+/**
+ * @param {{ active: string, isMobile?: boolean, csvMode?: boolean, onMode?: (key: string) => void,
+ *   children?: any, after?: any }} props
+ *   `children` sits after the map's tabs (the map page's sample or CSV chip),
+ *   `after` at the end of the row (the Auto scan button). `own` pages (Outlink,
+ *   Scan) need your own network, so they hide for the sample or a CSV.
+ */
+export default function AppTabs({ active, isMobile = false, csvMode = false, onMode, children, after }) {
+  const pad = isMobile ? '6px 10px' : '8px 16px';
+  const base = { padding: pad, borderRadius: 6, border: 'none', fontSize: isMobile ? 11 : 13, fontWeight: 600, textDecoration: 'none' };
+  return (
+    <div id="main-tabs" style={{ display: 'flex', gap: isMobile ? 2 : 4, background: 'rgba(255,255,255,0.08)', borderRadius: 8, padding: isMobile ? 2 : 3, flexWrap: isMobile ? 'wrap' : 'nowrap' }}>
+      {MODES.map((m) => {
+        const style = { ...base, cursor: 'pointer', ...(active === m.key ? m.on : m.off) };
+        const label = isMobile && m.short ? m.short : m.label;
+        return onMode
+          ? <button key={m.key} type="button" onClick={() => onMode(m.key)} style={style}>{label}</button>
+          : <Link key={m.key} href={`/?mode=${m.key}`} style={{ ...style, display: 'flex', alignItems: 'center' }}>{label}</Link>;
+      })}
+      {children}
+      {PAGES.filter((p) => (IS_DEMO ? false : p.own ? !csvMode : true)).map((p) => {
+        const on = active === p.key;
+        return (
+          <Link key={p.key} href={p.href} title={p.title} aria-current={on ? 'page' : undefined} style={{
+            ...base, display: 'flex', alignItems: 'center', gap: 4,
+            background: on ? p.on : 'rgba(255,255,255,0.06)', color: on ? '#000' : p.color,
+          }}>
+            {p.label}{p.badge && <span style={{ fontSize: 9, opacity: 0.7, marginLeft: 2 }}>{p.badge}</span>}
+          </Link>
+        );
+      })}
+      {after}
+    </div>
+  );
+}