six-degrees 0.4.2 → 0.4.3

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

@@ -295,11 +295,24 @@ const OrbitGraph = forwardRef(function OrbitGraph(
           placed += row.length;
           r += step;
         }
+        // Their people go behind this fan, centred on it (not on wherever the
+        // person they came through sits), side by side in the order those people
+        // sit, so no fan spills into the next one's space; a line runs back to
+        // each. Wider than the wedge, they close up to fit it.
         let edge = r;
-        for (const { d, a } of subs) {
-          if (depth >= 6 || !reachOf(d)) continue;
-          const sub = Math.min(wedge * 0.6, Math.max(0.12, (Math.min(reachOf(d), 60) * 8) / (r + 24)));
-          edge = Math.max(edge, placeFan(d, a, sub, r + 24, depth + 1));
+        const next = subs.filter(({ d }) => depth < 6 && reachOf(d)).sort((x, y) => x.a - y.a);
+        if (next.length) {
+          const from = r + 24;
+          const gap = 10 / from;
+          const want = next.map(({ d }) => Math.max(0.12, (Math.min(reachOf(d), 60) * 8) / from));
+          const need = want.reduce((sum, w) => sum + w, 0) + gap * (next.length - 1);
+          const scale = need > wedge ? wedge / need : 1;
+          let at = angle - (need * scale) / 2;
+          next.forEach(({ d }, k) => {
+            const w = want[k] * scale;
+            edge = Math.max(edge, placeFan(d, at + w / 2, w, from, depth + 1));
+            at += w + gap * scale;
+          });
         }
         return edge;
       };

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

@@ -0,0 +1,82 @@
+'use client';
+
+// The scan status bar: while a scan runs, every page shows what it's doing,
+// for whom, how far it's got, and today's LinkedIn budget, with Stop. Stop
+// saves what was read, and the Scan page's Resume carries on from that page.
+// It sits just under the header's tabs (Network Circle, Degrees…), on every
+// page, the Scan page too (Blake, 2026-09-29). It only reports: the
+// pacing and the caps live in the scanner (scripts/scrape.py, lib/linkedin-limits.js).
+
+import { useEffect, useState } from 'react';
+import Link from 'next/link';
+import { watchScanner, scannerNow, stopScrape } from '../../lib/scraper-client';
+
+const WHAT = {
+  full: 'Scanning your network',
+  refresh: 'Checking for new connections',
+  bridge: 'Scanning a circle',
+  resume: 'Carrying on with a circle',
+  'resume-all': 'Carrying on with circles',
+  'auto-bridge': 'Auto-Bridge',
+  'auto-bridge-retry': 'Auto-Bridge',
+  rescrape: 'Re-scanning a circle',
+  login: 'Signing in to LinkedIn',
+  setup: 'Setting up the scanner',
+  company: 'Scanning a company',
+  photos: 'Saving photos',
+};
+
+// Green while there's plenty left, amber past 60%, red past 90%.
+const tone = (used, cap) => (!cap ? '#8b9a9a' : used / cap >= 0.9 ? '#ff6b6b' : used / cap >= 0.6 ? '#FFD700' : '#00ff88');
+
+export default function ScanStatusBar() {
+  const [job, setJob] = useState(() => scannerNow());
+  const [stopping, setStopping] = useState(false);
+  useEffect(() => watchScanner(() => {
+    const now = scannerNow();
+    setJob(now);
+    if (!now.running) setStopping(false);
+  }), []);
+  if (!job?.running) return null;
+
+  const p = job.progress;
+  const step = p?.kind === 'batch' && p.total ? `${p.current || p.done || 0} of ${p.total}`
+    : p?.kind === 'walk' && p.total ? `${(p.done || 0).toLocaleString()} of ${p.total.toLocaleString()} read`
+    : p?.kind === 'saving' ? 'saving' : null;
+  const b = job.budget;
+  const last = [...(job.log || [])].reverse().find((l) => l && l.trim())?.trim();
+
+  return (
+    <div role="status" aria-live="polite" style={{
+      position: 'fixed', left: '50%', top: 'var(--scan-bar-top, 94px)', transform: 'translateX(-50%)', zIndex: 60,
+      maxWidth: 'calc(100vw - 32px)', display: 'flex', alignItems: 'center', gap: 12, flexWrap: 'nowrap', whiteSpace: 'nowrap',
+      padding: '8px 12px', borderRadius: 12, fontSize: 12, color: '#cfd8d8',
+      background: 'rgba(14,16,32,0.94)', border: '1px solid rgba(0,255,136,0.25)',
+    }}>
+      <span style={{ width: 8, height: 8, borderRadius: '50%', background: '#00ff88', flexShrink: 0 }} />
+      <b style={{ color: '#fff' }}>{WHAT[job.action] || 'Scanning'}</b>
+      {job.target?.name && <span>{job.target.name}</span>}
+      {step && <span style={{ color: '#8b9a9a' }}>{step}</span>}
+      {b && (
+        <span style={{ color: tone(b.searches, b.cap) }} title="Searches on your LinkedIn account in the last 24 hours, and your daily budget">
+          {b.searches}{b.cap ? ` of ${b.cap}` : ''} searches today
+        </span>
+      )}
+      {last && (
+        <span style={{ color: '#667', flex: '0 1 240px', minWidth: 0, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }} title={last}>
+          {last}
+        </span>
+      )}
+      <Link href="/setup" style={{ color: '#3498DB', textDecoration: 'none' }}>Details</Link>
+      <button
+        onClick={async () => { setStopping(true); try { await stopScrape(); } catch { setStopping(false); } }}
+        disabled={stopping}
+        title="Stops after saving what's been read; Resume on the Scan page carries on from the same page"
+        style={{
+          padding: '4px 10px', borderRadius: 8, fontSize: 12, cursor: stopping ? 'default' : 'pointer',
+          background: 'rgba(255,107,107,0.12)', color: '#ff9b9b', border: '1px solid rgba(255,107,107,0.35)',
+        }}
+      >{stopping ? 'Stopping…' : 'Stop'}</button>
+    </div>
+  );
+}

package/.next/standalone/app/globals.css

@@ -38,3 +38,7 @@ html:has([data-field-question]) {
   background: rgba(255, 255, 255, 0.15);
   border-radius: 3px;
 }
+
+/* Where the scan status bar sits: just under the header (app/components/ScanStatusBar.js). */
+:root { --scan-bar-top: 94px; }
+@media (max-width: 767px) { :root { --scan-bar-top: 66px; } }

package/.next/standalone/app/layout.js

@@ -19,6 +19,7 @@ export const metadata = {
 
 import UserProvider from './components/UserProvider';
 import StaleServerBanner from './components/StaleServerBanner';
+import ScanStatusBar from './components/ScanStatusBar';
 
 export default function RootLayout({ children }) {
   return (
@@ -30,6 +31,8 @@ export default function RootLayout({ children }) {
               is running. Every page, because the answer to "did my update
               work?" should not require finding the right screen. */}
           <StaleServerBanner />
+          {/* While a scan runs: what it's doing and today's budget, with Stop. */}
+          <ScanStatusBar />
         </UserProvider>
       </body>
     </html>

package/.next/standalone/app/page.js

@@ -73,6 +73,8 @@ function HomeInner() {
   const [degree3, setDegree3] = useState([]);
   // Which degrees Network Circle draws: your connections alone until you pick more.
   const [degrees, setDegrees] = useState([1]);
+  // Tiers switched off in Network Circle's Filter panel (C and D make a lot of noise).
+  const [hiddenTiers, setHiddenTiers] = useState([]);
   const [selected, setSelected] = useState(null);
   const focusNodeRef = useRef(null);
   const [filter, setFilter] = useState('all');
@@ -170,10 +172,10 @@ function HomeInner() {
     () => (isDegreesMode ? connections : degrees.flatMap((d) => byDegree[d] || [])),
     [isDegreesMode, connections, degrees, byDegree],
   );
-  const filtered = useMemo(
-    () => (filter === 'all' ? networkRows : networkRows.filter(c => c.tier === filter)),
-    [networkRows, filter],
-  );
+  const filtered = useMemo(() => {
+    if (!isDegreesMode) return hiddenTiers.length ? networkRows.filter(c => !hiddenTiers.includes(c.tier)) : networkRows;
+    return filter === 'all' ? networkRows : networkRows.filter(c => c.tier === filter);
+  }, [isDegreesMode, networkRows, filter, hiddenTiers]);
   // Lookups built once per load. Every click re-renders this component, and the
   // three places below used to scan one list inside another — degree1.find per
   // 2nd-degree row, degree2.some per connection — about 16M comparisons, twice
@@ -438,6 +440,8 @@ function HomeInner() {
           tierCounts={isDegreesMode ? stats?.tiers || {} : tierCountsOf(networkRows)}
           degrees={degrees}
           onDegreesChange={setDegrees}
+          hiddenTiers={hiddenTiers}
+          onHiddenTiersChange={setHiddenTiers}
           degreeCounts={{ 1: byDegree[1].length, 2: byDegree[2].length, 3: byDegree[3].length }}
           bridgeTierCounts={bridgeTierCounts}
         />

package/.next/standalone/app/setup/page.js

@@ -65,6 +65,8 @@ function SetupInner() {
   const [pages, setPages] = useRemembered('six-degrees-bridge-pages-v2', 100);
   // Also finish people mapped before, from the page each one's read stopped at.
   const [finish, setFinish] = useRemembered('six-degrees-bridge-finish', true);
+  // Experimental Auto-Bridge: all-day pacing and LinkedIn's own data (scripts/scrape.py --experimental).
+  const [experimental, setExperimental] = useRemembered('six-degrees-experimental-auto', false);
   const [error, setError] = useState(null);
   const logRef = useRef(null);
   // What's saved, for the question about your field: undefined while it
@@ -440,6 +442,16 @@ function SetupInner() {
                   <input type="checkbox" checked={finish} onChange={(e) => setFinish(e.target.checked)} disabled={running} />
                   Also finish people already mapped, from the page each one stopped at
                 </label>
+                <label style={{ display: 'flex', gap: 8, alignItems: 'flex-start', fontSize: 12.5, color: '#b8c4c4', cursor: running ? 'default' : 'pointer' }}>
+                  <input type="checkbox" checked={experimental} disabled={running} style={{ marginTop: 3 }}
+                    onChange={(e) => setExperimental(e.target.checked)} />
+                  <span>
+                    <b style={{ color: '#FFD700' }}>Experimental:</b> all-day pacing. Up to 10 pages in a sitting,
+                    then a 45-minute rest; searches only from 9:00 to 19:00; at the daily budget it waits for it to
+                    free up instead of stopping; and it saves every page. It also reads LinkedIn&rsquo;s own data beside
+                    the page text, to fill gaps and measure how the two compare. It keeps running while the app is open.
+                  </span>
+                </label>
                 <div style={{ fontSize: 12, color: '#FFD700', lineHeight: 1.6 }}>
                   Every page is a LinkedIn search, so it rests 20 seconds before each one and a
                   minute after every 10, and a long list can take
@@ -449,7 +461,7 @@ function SetupInner() {
                   what it read and stops, and carries on from that page next time. Keep batches small.
                 </div>
               <div style={{ display: 'flex', gap: 10, flexWrap: 'wrap', alignItems: 'center' }}>
-                <Btn onClick={() => run('auto-bridge', { maxBridges: batch, tiers: order === 'score' ? tiers : [], order, maxPages: pages, deeper: finish })} disabled={!canSearch || (order === 'score' && !tiers.length)} primary>
+                <Btn onClick={() => run('auto-bridge', { maxBridges: batch, tiers: order === 'score' ? tiers : [], order, maxPages: pages, deeper: finish, experimental })} disabled={!canSearch || (order === 'score' && !tiers.length)} primary>
                   {running && s.action === 'auto-bridge' ? 'Mapping…' : 'Map 2nd degree'}
                 </Btn>
                 <select

package/.next/standalone/lib/scraper-client.js

@@ -148,6 +148,7 @@ function take(s) {
     target: running ? s.target ?? null : starting ? now.target : null,
     startedAt: running ? s.startedAt ?? null : null,
     progress: running ? s.progress ?? null : null,
+    budget: running ? s.budget ?? null : null,
     log: running && Array.isArray(s.log) ? s.log : [],
     finished,
   });

package/.next/standalone/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "six-degrees",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "six-degrees",
-      "version": "0.4.2",
+      "version": "0.4.3",
       "license": "MIT",
       "os": [
         "darwin",

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "six-degrees",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Map your professional network as a galaxy — leverage tiers, bridges into new circles, and the shortest path to anyone. Runs locally on your own data.",
   "license": "MIT",
   "author": "Blake Burford",

package/.next/standalone/scripts/scrape.py

@@ -27,11 +27,12 @@ in one session — LinkedIn detects automation and flags your account.
 import argparse
 import json
 import os
+import re
 import signal
 import sys
 import time
 import requests
-from datetime import datetime
+from datetime import datetime, timedelta
 from pathlib import Path
 from urllib.parse import parse_qs, urlparse
 
@@ -1274,6 +1275,17 @@ PAGE_PAUSE = 20                   # seconds before each next page of results
 CHUNK_COOLDOWN = 60               # extra seconds after every SAVE_EVERY_PAGES pages
 LEGACY_PAGES_READ = 10            # how far every read before 0.1.6 went, at most
 
+# Experimental all-day pacing for Auto-Bridge (--experimental; item 44, Graph
+# Study §8). Openly slow, never disguised: fixed waits, no random "human" timing.
+# A sitting of SESSION_PAGES searches, then a long rest; searches only in the
+# daytime on this computer's clock; and at the daily budget it waits for the
+# budget to free up instead of stopping. Pages are saved one at a time.
+EXPERIMENT = {"on": False, "pages": 0, "wire": 0}
+SESSION_PAGES = 10                # searches in one sitting
+SESSION_REST = 45 * 60            # the rest after each sitting
+DRIP_HOURS = (9, 19)              # searches only from 09:00 to 19:00, local time
+WIRE_SAMPLES = 5                  # raw LinkedIn responses kept per run, for research
+
 
 # Someone whose connections are hidden can never produce a 2nd-degree row. The
 # "who still needs bridging" query is "everyone with no 2nd-degree rows", so
@@ -1787,6 +1799,193 @@ def stop_requested():
     return _stop_requested
 
 
+# LinkedIn's own data (experimental, with --experimental). While a circle is
+# read, the responses the browser already gets from LinkedIn's own API are kept
+# and read for the same people the page shows: the same traffic, no extra
+# requests. The page text stays in charge. This fills blanks for people both
+# found and gives the list's real total; people only in LinkedIn's data are
+# logged, not added, since a results page can carry other boxes ("People you
+# may know"). Each page logs how the two compare, and a few raw responses are
+# kept in the data folder (wire-samples/) to tune it from real ones.
+_WIRE = {"page": None, "responses": []}
+
+
+def _wire_tap(page):
+    if _WIRE["page"] is page:
+        return
+    _WIRE["page"], _WIRE["responses"] = page, []
+
+    def keep(response):
+        url = response.url
+        if "/voyager/api/" in url and ("search" in url.lower() or "graphql" in url):
+            _WIRE["responses"].append(response)
+    page.on("response", keep)
+
+
+def mutual_count_text(text):
+    """LinkedIn's mutual line as a number, as the page reader's mutualCount reads it; None otherwise."""
+    line = re.sub(r"\s+", " ", str(text or "")).strip()
+    if not re.search(r"\bmutual connections?$", line, re.I) or len(line) > 300:
+        return None
+    num = lambda v: int(str(v).replace(",", ""))
+    names = lambda v: len([p for p in re.split(r"\s*,\s*|\s+and\s+", v) if p])
+    m = re.match(r"^([\d,]+) mutual connections?$", line, re.I)
+    if m:
+        return num(m.group(1))
+    m = re.match(r"^(.*?)\s*\band ([\d,]+) others? mutual connections?$", line, re.I)
+    if m:
+        return max(1, names(m.group(1))) + num(m.group(2))
+    if re.search(r"\bis a mutual connection$", line, re.I):
+        return 1
+    m = re.match(r"^(.+?)\s+are mutual connections$", line, re.I)
+    return names(m.group(1)) if m else None
+
+
+def voyager_people(payload):
+    """Everyone in a LinkedIn API response who looks like a search result: anything with a
+    title and a link to a profile, wherever it sits in the response."""
+    out, seen = [], set()
+    text = lambda v: (v.get("text") if isinstance(v, dict) else v if isinstance(v, str) else "") or ""
+
+    def photo(x):
+        try:
+            for a in (x.get("image") or {}).get("attributes") or []:
+                vi = ((a.get("detailData") or {}).get("nonEntityProfilePicture") or {}).get("vectorImage") or a.get("vectorImage")
+                if vi and vi.get("rootUrl") and vi.get("artifacts"):
+                    best = max(vi["artifacts"], key=lambda f: f.get("width") or 0)
+                    return vi["rootUrl"] + (best.get("fileIdentifyingUrlPathSegment") or "")
+        except Exception:
+            pass
+        return ""
+
+    def walk(x):
+        if isinstance(x, dict):
+            nav = x.get("navigationUrl")
+            if isinstance(nav, str) and "/in/" in nav and isinstance(x.get("title"), dict):
+                url = nav.split("?")[0].split("#")[0].rstrip("/") + "/"
+                name = text(x.get("title")).strip()
+                if name and name != "LinkedIn Member" and url not in seen:
+                    seen.add(url)
+                    mutual = None
+                    for ins in x.get("insightsResolutionResults") or []:
+                        mutual = mutual_count_text(text(((ins or {}).get("simpleInsight") or {}).get("title")))
+                        if mutual:
+                            break
+                    out.append({"name": name, "headline": text(x.get("primarySubtitle")).strip(),
+                                "profileUrl": url, "imageUrl": photo(x), "mutualCount": mutual})
+            for v in x.values():
+                walk(v)
+        elif isinstance(x, list):
+            for v in x:
+                walk(v)
+    walk(payload)
+    return out
+
+
+def voyager_total(payload):
+    """The list's length, when a response says it (totalResultCount); None otherwise."""
+    stack = [payload]
+    while stack:
+        x = stack.pop()
+        if isinstance(x, dict):
+            v = x.get("totalResultCount")
+            if isinstance(v, int) and v > 0:
+                return v
+            stack.extend(x.values())
+        elif isinstance(x, list):
+            stack.extend(x)
+    return None
+
+
+def _wire_sample(data):
+    if EXPERIMENT["wire"] >= WIRE_SAMPLES:
+        return
+    try:
+        raw = json.dumps(data)
+        if len(raw) > 500_000:
+            return
+        folder = _home() / "wire-samples"
+        folder.mkdir(parents=True, exist_ok=True)
+        (folder / f"{int(time.time() * 1000)}.json").write_text(raw)
+        EXPERIMENT["wire"] += 1
+    except Exception:
+        pass
+
+
+def _wire_merge(page, profile_url, page_results):
+    """Fill blanks in this page's people from LinkedIn's own data, and log how the two compare."""
+    got, _WIRE["responses"] = _WIRE["responses"], []
+    people, total = [], None
+    for response in got:
+        try:
+            data = response.json()
+        except Exception:
+            continue
+        _wire_sample(data)
+        people.extend(voyager_people(data))
+        total = total or voyager_total(data)
+    if total:
+        _LIST_TOTALS[profile_url] = int(total)
+    own = (profile_url or "").rstrip("/").split("/")[-1]
+    by_url = {c.get("profileUrl"): c for c in page_results}
+    only_wire = 0
+    for w in people:
+        if own and own in w["profileUrl"]:
+            continue
+        c = by_url.get(w["profileUrl"])
+        if c is None:
+            only_wire += 1
+            continue
+        for k in ("name", "headline", "imageUrl"):
+            if not c.get(k) and w.get(k):
+                c[k] = w[k]
+        if c.get("mutualCount") is None and w.get("mutualCount") is not None:
+            c["mutualCount"] = w["mutualCount"]
+    print(f"    LinkedIn's own data: {len(people)} people, {only_wire} not in the page text"
+          + (f", list of about {total:,}" if total else ""), flush=True)
+    return page_results
+
+
+def _drip_wait(label, seconds):
+    """Wait `seconds` for an experimental rest, saying when it ends, a line a minute. False if stopped."""
+    seconds = max(1, int(seconds))
+    until = datetime.fromtimestamp(time.time() + seconds).strftime("%H:%M")
+    print(f"  {label}. Carrying on at {until}.", flush=True)
+    return interruptible_sleep(seconds, on_tick=lambda left: print(f"    {label}: {max(1, left // 60)} min to go", flush=True), step=60)
+
+
+def _seconds_until_search_frees(now=None):
+    """How long until the oldest search in the last 24 hours drops out of the daily budget."""
+    now = now if now is not None else time.time()
+    recent = sorted(t for t in _read_activity()["searches"] if now - DAY_SECONDS < t <= now)
+    return (recent[0] + DAY_SECONDS - now + 5) if recent else 5
+
+
+def _drip_before_search():
+    """Experimental pacing, before a search: rest after a sitting, sleep through the
+    night, and wait for a used daily budget to free up. True to go ahead, False if stopped."""
+    while True:
+        if EXPERIMENT["pages"] >= SESSION_PAGES:
+            EXPERIMENT["pages"] = 0
+            if not _drip_wait(f"Resting after {SESSION_PAGES} pages", SESSION_REST):
+                return False
+            continue
+        now = datetime.fromtimestamp(time.time())
+        if not (DRIP_HOURS[0] <= now.hour < DRIP_HOURS[1]):
+            start = now.replace(hour=DRIP_HOURS[0], minute=0, second=0, microsecond=0)
+            if now.hour >= DRIP_HOURS[1]:
+                start += timedelta(days=1)
+            if not _drip_wait("Resting overnight", (start - now).total_seconds()):
+                return False
+            continue
+        left, kind = searches_left()
+        if left <= 0 and kind == "daily":
+            if not _drip_wait("Today's searches are used", _seconds_until_search_frees()):
+                return False
+            continue
+        return True
+
+
 def interruptible_sleep(seconds, on_tick=None, step=5):
     """Sleep, but notice a stop request. Returns False if we were interrupted."""
     waited = 0
@@ -2402,6 +2601,12 @@ def _scrape_one_bridge(page, bridge_name, bridge_id, profile_url, max_pages=LINK
     # 1st, 2nd and 3rd+ — all of them; the app drops your own connections when
     # it saves. It used to be announced as a "3rd+ filter", which it never was.
     search_url = f"https://www.linkedin.com/search/results/people/?network=%5B%22F%22%2C%22S%22%2C%22O%22%5D&connectionOf=%5B%22{urn}%22%5D"
+    if EXPERIMENT["on"] and not _drip_before_search():
+        reach["more"] = True
+        print("  Stopped before their list opened; the next run carries on from there.")
+        return [], "stopped", reach
+    if EXPERIMENT["on"]:
+        _wire_tap(page)
     left, kind = searches_left()
     if left <= 0:
         reach["budget"] = kind
@@ -2547,6 +2752,9 @@ def _scrape_one_bridge(page, bridge_name, bridge_id, profile_url, max_pages=LINK
             break
 
         page_results = [c for c in page_results if slug not in c.get("profileUrl", "")]
+        if EXPERIMENT["on"]:
+            page_results = _wire_merge(page, profile_url, page_results)
+            EXPERIMENT["pages"] += 1
         chunk.extend(page_results)
         chunk_pages += 1
         reach["last"] = pg
@@ -2569,7 +2777,7 @@ def _scrape_one_bridge(page, bridge_name, bridge_id, profile_url, max_pages=LINK
         # own path: through the page-limit branch, a missing Next button would
         # have marked the list finished.
         left, kind = searches_left()
-        if left <= 0:
+        if left <= 0 and not (EXPERIMENT["on"] and kind == "daily"):
             # Looking for Next costs nothing. No Next on a live page of results
             # means the list is finished — not paused at the next page forever.
             if _find_next(page) is None and not _window_closed(page) and _result_links(page):
@@ -2582,10 +2790,10 @@ def _scrape_one_bridge(page, bridge_name, bridge_id, profile_url, max_pages=LINK
 
         # Rest before the next search, and longer after every SAVE_EVERY_PAGES.
         rest = PAGE_PAUSE
-        if (pg - start_page + 1) % SAVE_EVERY_PAGES == 0:
+        if not EXPERIMENT["on"] and (pg - start_page + 1) % SAVE_EVERY_PAGES == 0:
             rest += CHUNK_COOLDOWN
             print(f"  {SAVE_EVERY_PAGES} pages read; resting {rest}s before the next search.")
-        if not interruptible_sleep(rest) or _window_closed(page):
+        if not interruptible_sleep(rest) or _window_closed(page) or (EXPERIMENT["on"] and not _drip_before_search()):
             reach["more"] = True
             print(f"  Stopped before page {pg + 1}; the next run carries on from there.")
             break
@@ -2610,7 +2818,7 @@ def _scrape_one_bridge(page, bridge_name, bridge_id, profile_url, max_pages=LINK
 
         # Save as it goes, so a stop, a crash or the search limit costs at most
         # the last few pages rather than the whole list.
-        if on_save and chunk_pages >= SAVE_EVERY_PAGES:
+        if on_save and chunk_pages >= (1 if EXPERIMENT["on"] else SAVE_EVERY_PAGES):
             on_save(_dedupe(chunk), reach["last"], True, reach["urn"])
             chunk, chunk_pages = [], 0
 
@@ -3752,6 +3960,9 @@ Examples:
     parser.add_argument("--bridge", type=str, help="Name of one bridge person to scrape")
     parser.add_argument("--rescrape", type=str, help="Delete + re-scrape a bridge's cluster from scratch")
     parser.add_argument("--company", type=str, help="Scan everyone the app can see at one company")
+    parser.add_argument("--experimental", action="store_true",
+                        help="Auto-Bridge, experimental: all-day pacing (sittings, rests, daytime only, "
+                             "waits for the daily budget) and reading LinkedIn's own data beside the page text")
     parser.add_argument("--auto-bridge", action="store_true",
                         help="Map every bridge in turn, highest tier first")
     parser.add_argument("--retry-private", action="store_true",
@@ -3783,6 +3994,9 @@ Examples:
                              "(every scan also does this at its end)")
     parser.add_argument("--headless", action="store_true", help="Run browser in headless mode")
     args = parser.parse_args()
+    if getattr(args, "experimental", False):
+        EXPERIMENT["on"] = True
+        print("Experimental Auto-Bridge: all-day pacing, and LinkedIn's own data read beside the page text.")
     args.max_pages = max(1, min(LINKEDIN_MAX_PAGES, args.max_pages))
 
     # A failed save ends the run with its reason, not a traceback (TRAPS §32).