Upload 9 files

uploaded initial files.....read me to come......

chat-traffic-gate-leader-softcap.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:144efa928d7262af4fb687c7a1ddf3197430584a88f827ce2cb43427ddeba722
+size 14157

chat-traffic-gate-leader-softcap/background.js

@@ -0,0 +1,227 @@
+// background.js — Firefox MV3 event page
+// Tight history gating: only cancel true pagination. No blanket GET cancels.
+// Leader/follower model: only the active GPT tab runs keepalive pings.
+
+const api = (typeof browser !== 'undefined') ? browser : chrome;
+
+let cfg = { blockHistory: true, debug: false };
+const intent = new Map();       // tabId -> bool (user intends history load)
+const allowUntil = new Map();   // tabId -> ms timestamp
+
+const GPT_URLS = ['https://chat.openai.com/*', 'https://chatgpt.com/*'];
+const GPT_HOST_RE = /^(chat\.openai\.com|chatgpt\.com)$/;
+
+let leaderTabId = null;
+
+function isGptUrl(url) {
+  try {
+    const u = new URL(url);
+    return GPT_HOST_RE.test(u.hostname);
+  } catch { return false; }
+}
+
+async function getActiveTabId() {
+  try {
+    const tabs = await api.tabs.query({ active: true, currentWindow: true });
+    if (!tabs || !tabs.length) return null;
+    const t = tabs[0];
+    if (t && typeof t.id === 'number' && isGptUrl(t.url || '')) return t.id;
+  } catch {}
+  return null;
+}
+
+async function setLeader(tabId) {
+  try {
+    const newLeader = (typeof tabId === 'number') ? tabId : await getActiveTabId();
+    if (newLeader === leaderTabId) return;
+
+    const oldLeader = leaderTabId;
+    leaderTabId = newLeader;
+
+    // Tell old leader to stand down
+    if (typeof oldLeader === 'number') {
+      api.tabs.sendMessage(oldLeader, { type: 'tgRole', role: 'follower' }).catch(()=>{});
+    }
+    // Tell new leader to take over
+    if (typeof leaderTabId === 'number') {
+      api.tabs.sendMessage(leaderTabId, { type: 'tgRole', role: 'leader' }).catch(()=>{});
+    }
+  } catch {}
+}
+
+// Wake the event page periodically (Firefox MV3 event page)
+try { api.alarms?.create('tg-ping', { periodInMinutes: 4 }); } catch {}
+
+(async () => {
+  try {
+    const got = await api.storage.local.get({ blockHistory: true, debug: false });
+    cfg.blockHistory = !!got.blockHistory;
+    cfg.debug = !!got.debug;
+  } catch {}
+  // Establish an initial leader if a GPT tab is already active
+  await setLeader(null);
+})();
+
+api.storage.onChanged.addListener((c, area) => {
+  if (area !== 'local') return;
+  if (c.blockHistory) cfg.blockHistory = !!c.blockHistory.newValue;
+  if (c.debug) cfg.debug = !!c.debug.newValue;
+});
+
+// Cleanup per-tab state to avoid stale intent/timers.
+try {
+  api.tabs?.onRemoved?.addListener((tabId) => {
+    try { intent.delete(tabId); } catch {}
+    try { allowUntil.delete(tabId); } catch {}
+    if (leaderTabId === tabId) {
+      leaderTabId = null;
+      setLeader(null);
+    }
+  });
+
+  api.tabs?.onUpdated?.addListener((tabId, changeInfo, tab) => {
+    try {
+      if (!changeInfo) return;
+
+      // If the tab navigates away from GPT, clear state
+      if (changeInfo.url && !isGptUrl(changeInfo.url)) {
+        intent.delete(tabId);
+        allowUntil.delete(tabId);
+        if (leaderTabId === tabId) {
+          leaderTabId = null;
+          setLeader(null);
+        }
+      }
+
+      // If this tab becomes active and is GPT, promote to leader
+      if (tab && tab.active && isGptUrl(tab.url || changeInfo.url || '')) {
+        setLeader(tabId);
+      }
+    } catch {}
+  });
+
+  api.tabs?.onActivated?.addListener(async (info) => {
+    try {
+      const tab = await api.tabs.get(info.tabId);
+      if (tab && isGptUrl(tab.url || '')) await setLeader(info.tabId);
+    } catch {}
+  });
+} catch {}
+
+// Background ping (best-effort) — only when at least one GPT tab exists.
+async function anyGptTabsOpen() {
+  try {
+    const tabs = await api.tabs.query({ url: GPT_URLS });
+    return !!(tabs && tabs.length);
+  } catch { return false; }
+}
+
+async function bgPingOnce(url) {
+  try {
+    const ctl = new AbortController();
+    const t = setTimeout(() => { try { ctl.abort(); } catch {} }, 6000);
+    const res = await fetch(url, { method: 'GET', cache: 'no-store', credentials: 'include', signal: ctl.signal });
+    clearTimeout(t);
+    return !!res;
+  } catch { return false; }
+}
+
+try {
+  api.alarms?.onAlarm?.addListener(async (a) => {
+    if (!a || a.name !== 'tg-ping') return;
+    if (!(await anyGptTabsOpen())) return;
+
+    // Ping both; whichever has cookies will work. Ignore failures.
+    await bgPingOnce('https://chatgpt.com/api/auth/session');
+    await bgPingOnce('https://chat.openai.com/api/auth/session');
+  });
+} catch {}
+
+api.runtime.onMessage.addListener((msg, sender) => {
+  const tabId = sender?.tab?.id;
+  if (typeof tabId !== 'number') return;
+  try {
+    if (msg?.type === 'historyIntent') {
+      intent.set(tabId, !!msg.value);
+    } else if (msg?.type === 'toggleBlockHistory') {
+      cfg.blockHistory = !!msg.value;
+      api.storage.local.set({ blockHistory: cfg.blockHistory });
+    } else if (msg?.type === 'requestStatus') {
+      const role = (leaderTabId === tabId) ? 'leader' : 'follower';
+      return Promise.resolve({
+        blockHistory: cfg.blockHistory,
+        intent: !!intent.get(tabId),
+        allowUntil: allowUntil.get(tabId) || 0,
+        role
+      });
+    } else if (msg?.type === 'allowHistoryForMs') {
+      const ms = Math.max(2000, Math.min(60000, Number(msg.ms) || 10000));
+      const until = Date.now() + ms;
+      allowUntil.set(tabId, until);
+      setTimeout(() => {
+        if ((allowUntil.get(tabId) || 0) <= Date.now()) allowUntil.delete(tabId);
+      }, ms + 250);
+    } else if (msg?.type === 'becomeLeader') {
+      // Optional: content can request leadership if it is the visible tab.
+      setLeader(tabId);
+    }
+  } catch (e) {
+    console.warn('[TrafficGate] bg onMessage error', e);
+  }
+});
+
+function hasPagination(u) {
+  try {
+    const q = u.searchParams;
+    if (q.has('cursor') || q.has('before')) return true;
+    if (q.has('offset') && Number(q.get('offset')) > 0) return true;
+    if (q.has('page') && Number(q.get('page')) > 1) return true;
+    const dir = (q.get('direction') || '').toLowerCase();
+    if (/back|prev|previous/.test(dir)) return true;
+  } catch {}
+  return false;
+}
+
+function isHistoryLoad(details) {
+  try {
+    const u = new URL(details.url);
+    if (!GPT_HOST_RE.test(u.hostname)) return false;
+    const method = (details.method || 'GET').toUpperCase();
+    if (method !== 'GET' && method !== 'POST') return false;
+
+    const p = u.pathname.toLowerCase();
+
+    // Allow-list some essentials outright
+    if (/\/api\/auth\/session$/.test(p)) return false;
+    if (/\/backend-api\/models$/.test(p)) return false;
+
+    // Consider "history-like" paths but only block when explicit pagination shows up
+    const looksHistoryPath = /(backend-api\/conversation|backend-api\/conversations|backend-api\/messages|\/history|\/messages|\/conversation|\/threads|\/graphql|\/gql|\/v1\/messages|\/v1\/threads)/.test(p);
+    if (!looksHistoryPath) return false;
+
+    // Only treat as history when pagination markers are present
+    return hasPagination(u);
+  } catch { return false; }
+}
+
+try {
+  api.webRequest?.onBeforeRequest.addListener(
+    (details) => {
+      try {
+        if (!cfg.blockHistory) return {};
+        if (details.type !== 'xmlhttprequest' && details.type !== 'fetch') return {};
+        const tabId = details.tabId;
+        const now = Date.now();
+        const okByTimer = (allowUntil.get(tabId) || 0) > now;
+        const okByIntent = !!intent.get(tabId);
+        if (!okByTimer && !okByIntent && isHistoryLoad(details)) {
+          if (cfg.debug) console.log('[TrafficGate] CANCEL', details.url);
+          return { cancel: true };
+        }
+      } catch (e) { console.warn('[TrafficGate] onBeforeRequest', e); }
+      return {};
+    },
+    { urls: ['https://chat.openai.com/*', 'https://chatgpt.com/*'] },
+    ['blocking', 'requestBody']
+  );
+} catch {}

chat-traffic-gate-leader-softcap/content/autopilot.js

@@ -0,0 +1,118 @@
+// content/autopilot.js — visible-tab autopilot only (reduces background overhead)
+
+(function () {
+  'use strict';
+  const api = (typeof browser !== 'undefined') ? browser : chrome;
+
+  const stats = { cancels: 0, disconnects: 0, longtasks: 0, lastTurnCount: 0 };
+  const cfg = { topPx: 180, minTopPx: 80, softcapKeep: 60, minKeep: 30 };
+
+  Object.defineProperty(window, '__tgTelemetry', {
+    value: function (event, data) {
+      try {
+        if (event === 'historyCancel') stats.cancels++;
+        else if (event === 'disconnect') stats.disconnects++;
+        else if (event === 'turnCount' && typeof data?.count === 'number') stats.lastTurnCount = data.count;
+      } catch {}
+    },
+    writable: false, configurable: false, enumerable: false
+  });
+
+  let po = null;
+  function startLongTaskObserver() {
+    try {
+      if (po) return;
+      po = new PerformanceObserver((list) => {
+        for (const e of list.getEntries()) if (e.duration >= 200) stats.longtasks++;
+      });
+      po.observe({ entryTypes: ['longtask'] });
+    } catch { po = null; }
+  }
+  function stopLongTaskObserver() {
+    try { if (po) po.disconnect(); } catch {}
+    po = null;
+  }
+
+  let lastScrollTop = 0;
+  let lastUpAt = 0;
+  let scrollHandler = null;
+  let tuneTimer = null;
+  let intentTimer = null;
+
+  function updateIntent() {
+    if (document.visibilityState !== 'visible') return;
+    const sc = document.scrollingElement || document.documentElement;
+    const st = sc.scrollTop || 0;
+    const now = Date.now();
+    if (st < lastScrollTop - 2) lastUpAt = now;
+    lastScrollTop = st;
+
+    const nearTop = (st < cfg.topPx);
+    const recentUp = (now - lastUpAt) < 1500;
+    const allow = !!(nearTop || recentUp);
+
+    try { window.__chatTrafficGate?.setIntent(allow); } catch {}
+    api.runtime.sendMessage({ type: 'historyIntent', value: allow }).catch(()=>{});
+  }
+
+  async function tune() {
+    if (document.visibilityState !== 'visible') return;
+    const cancels = stats.cancels, disc = stats.disconnects, jank = stats.longtasks, turns = stats.lastTurnCount;
+    stats.cancels = stats.disconnects = stats.longtasks = 0;
+
+    if (disc >= 2) {
+      try { window.__chatKeepalive?.setMinutes(3); } catch {}
+      try { window.__chatKeepalive?.setAutoReconnect(true); } catch {}
+      try { window.__chatKeepalive?.setAllowReloads(true); } catch {}
+    }
+    if (jank >= 4 || (turns && turns > cfg.softcapKeep + 10)) {
+      cfg.softcapKeep = Math.max(cfg.minKeep, (cfg.softcapKeep || 60) - 10);
+      try { window.__chatSoftCap?.setConfig({ enabled: true, keep: cfg.softcapKeep }); } catch {}
+    }
+    if (cancels >= 20) cfg.topPx = Math.max(cfg.minTopPx, cfg.topPx - 20);
+
+    if (disc === 0 && jank <= 1 && cancels < 5) {
+      if ((cfg.softcapKeep || 60) < 60) {
+        cfg.softcapKeep = Math.min(60, (cfg.softcapKeep || 60) + 10);
+        try { window.__chatSoftCap?.setConfig({ enabled: true, keep: cfg.softcapKeep }); } catch {}
+      }
+      if (cfg.topPx < 180) cfg.topPx += 10;
+      try { window.__chatKeepalive?.setMinutes(4); } catch {}
+      try { window.__chatKeepalive?.setAllowReloads(false); } catch {}
+    }
+  }
+
+  function startVisibleMode() {
+    startLongTaskObserver();
+
+    if (!scrollHandler) {
+      scrollHandler = () => updateIntent();
+      window.addEventListener('scroll', scrollHandler, { passive: true });
+    }
+    if (!intentTimer) intentTimer = setInterval(updateIntent, 2000);
+    if (!tuneTimer) tuneTimer = setInterval(tune, 40000);
+
+    updateIntent();
+    setTimeout(tune, 5000);
+  }
+
+  function stopVisibleMode() {
+    stopLongTaskObserver();
+    if (scrollHandler) {
+      try { window.removeEventListener('scroll', scrollHandler); } catch {}
+      scrollHandler = null;
+    }
+    if (intentTimer) { clearInterval(intentTimer); intentTimer = null; }
+    if (tuneTimer) { clearInterval(tuneTimer); tuneTimer = null; }
+    try { window.__chatTrafficGate?.setIntent(false); } catch {}
+    api.runtime.sendMessage({ type: 'historyIntent', value: false }).catch(()=>{});
+  }
+
+  document.addEventListener('visibilitychange', () => {
+    if (document.visibilityState === 'visible') startVisibleMode();
+    else stopVisibleMode();
+  }, { passive: true });
+
+  if (document.visibilityState === 'visible') startVisibleMode();
+  else stopVisibleMode();
+})();

chat-traffic-gate-leader-softcap/content/dom-softcap.js

@@ -0,0 +1,161 @@
+// content/dom-softcap.js — dynamic softcap per tab visibility (active vs background)
+
+(function () {
+  'use strict';
+  const SELECTOR_TURN = '[data-testid^="conversation-turn-"]';
+  const state = {
+    enabled: true,
+    keep: 60,           // current effective keep
+    keepActive: 60,     // when tab is visible
+    keepHidden: 20,     // when tab is hidden
+    keepDeepHidden: 12, // after being hidden for a while
+    deepHiddenAfterMs: 10 * 60 * 1000,
+    hiddenSince: null,
+    container: null,
+    observer: null,
+    firstDone: false,
+    dirty: true,
+    lastTrim: 0
+  };
+
+  const tlog = (...args) => { try { window.__tgTelemetry?.apply(null, args); } catch {} };
+
+  Object.defineProperty(window, '__chatSoftCap', {
+    value: {
+      setConfig: (cfg) => {
+        if (!cfg || typeof cfg !== 'object') return;
+        if (typeof cfg.enabled === 'boolean') state.enabled = cfg.enabled;
+        if (typeof cfg.keep === 'number' && isFinite(cfg.keep)) state.keepActive = Math.max(20, Math.min(300, Math.floor(cfg.keep)));
+        if (typeof cfg.keepHidden === 'number' && isFinite(cfg.keepHidden)) state.keepHidden = Math.max(10, Math.min(200, Math.floor(cfg.keepHidden)));
+        if (typeof cfg.keepDeepHidden === 'number' && isFinite(cfg.keepDeepHidden)) state.keepDeepHidden = Math.max(5, Math.min(100, Math.floor(cfg.keepDeepHidden)));
+        state.dirty = true;
+        applyMode();
+        schedule(30);
+      }
+    },
+    writable: false, configurable: false, enumerable: false
+  });
+
+  function applyMode() {
+    const vis = document.visibilityState;
+    const now = Date.now();
+    if (vis === 'hidden') {
+      if (!state.hiddenSince) state.hiddenSince = now;
+      const deep = (now - state.hiddenSince) >= state.deepHiddenAfterMs;
+      state.keep = deep ? state.keepDeepHidden : state.keepHidden;
+    } else {
+      state.hiddenSince = null;
+      state.keep = state.keepActive;
+    }
+  }
+
+  function findContainer() {
+    const first = document.querySelector(SELECTOR_TURN);
+    if (!first) return null;
+    let p = first.parentElement;
+    while (p && p !== document.body) {
+      const kids = Array.from(p.children).filter((el) => el.nodeType === 1);
+      if (kids.length && kids.every((el) => el.matches(SELECTOR_TURN))) return p;
+      p = p.parentElement;
+    }
+    return first.parentElement || null;
+  }
+
+  function isPure(node) {
+    if (!node) return false;
+    const kids = Array.from(node.children).filter((el) => el.nodeType === 1);
+    return kids.length && kids.every((el) => el.matches(SELECTOR_TURN));
+  }
+
+  function nodes() {
+    if (!state.container) return [];
+    return Array.from(state.container.querySelectorAll(SELECTOR_TURN));
+  }
+
+  function doTrimWork() {
+    if (!state.enabled || !state.container) return;
+    applyMode();
+
+    const list = nodes();
+    const tot = list.length;
+
+    tlog('turnCount', { count: tot, keep: state.keep, vis: document.visibilityState });
+
+    const extra = tot - state.keep;
+    if (extra > 0) {
+      const cutoff = tot - state.keep;
+      const keep = list.slice(cutoff);
+      const old = state.container.style.display;
+      state.container.style.display = 'none';
+      if (isPure(state.container)) {
+        state.container.replaceChildren(...keep);
+      } else {
+        for (let i = 0; i < cutoff; i++) list[i].remove();
+      }
+      state.container.style.display = old;
+      tlog('trim', { removed: cutoff, kept: state.keep });
+    }
+
+    state.lastTrim = Date.now();
+    state.dirty = false;
+
+    if (!state.firstDone) {
+      state.firstDone = true;
+      try { window.dispatchEvent(new Event('tg-unshield')); } catch {}
+    }
+  }
+
+  function trim() { try { doTrimWork(); } catch {} }
+
+  let t = null;
+  function schedule(ms = 0) {
+    if (t) clearTimeout(t);
+    t = setTimeout(() => {
+      try {
+        if ('requestIdleCallback' in window) {
+          requestIdleCallback(() => trim(), { timeout: 1200 });
+        } else {
+          trim();
+        }
+      } catch { trim(); }
+    }, ms);
+  }
+
+  function watch() {
+    const c = findContainer();
+    if (!c) return;
+    if (state.container !== c) {
+      if (state.observer) try { state.observer.disconnect(); } catch {}
+      state.container = c;
+      state.dirty = true;
+      state.observer = new MutationObserver(() => { state.dirty = true; schedule(40); });
+      state.observer.observe(state.container, { childList: true });
+      schedule(80);
+    }
+  }
+
+  function heartbeat() {
+    watch();
+    if (state.dirty) schedule(80);
+  }
+
+  document.addEventListener('visibilitychange', () => {
+    applyMode();
+    state.dirty = true;
+    schedule(120);
+  }, { passive: true });
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', () => {
+      watch();
+      applyMode();
+      schedule(160);
+      setInterval(heartbeat, 2000);
+    }, { once: true });
+  } else {
+    watch();
+    applyMode();
+    schedule(160);
+    setInterval(heartbeat, 2000);
+  }
+})();

chat-traffic-gate-leader-softcap/content/early-shield.js

@@ -0,0 +1,30 @@
+// content/early-shield.js — document_start CSS shield (auto-unshields safely)
+
+(() => {
+  try {
+    const style = document.createElement('style');
+    style.id = 'tg-early-shield';
+    style.textContent = `
+      html.tg-shield [data-testid^="conversation-turn-"] { display: none !important; }
+      html.tg-shield [data-testid="conversation-turns"] { visibility: hidden !important; }
+    `;
+    document.documentElement.classList.add('tg-shield');
+    document.documentElement.appendChild(style);
+
+    // Safety valve: auto-unshield after 2.5s even if no trim fired
+    setTimeout(() => {
+      try {
+        document.documentElement.classList.remove('tg-shield');
+        style.remove();
+      } catch {}
+    }, 2500);
+
+    // Preferred path: listen for explicit unshield event
+    window.addEventListener('tg-unshield', () => {
+      try {
+        document.documentElement.classList.remove('tg-shield');
+        style.remove();
+      } catch {}
+    }, { once: true });
+  } catch {}
+})();

chat-traffic-gate-leader-softcap/content/keepalive.js

@@ -0,0 +1,195 @@
+// content/keepalive.js — keep session warm; leader-only pinger; no auto-discard
+
+(function() {
+  'use strict';
+  const api = (typeof browser !== 'undefined') ? browser : chrome;
+  const tlog = (...args) => { try { window.__tgTelemetry?.apply(null, args); } catch {} };
+
+  const state = {
+    enabled: true,          // overall module on/off
+    pingEnabled: false,     // leader-only pings (big reducer when many tabs)
+    role: 'follower',       // 'leader' | 'follower'
+    minutes: 4,
+    autoReconnect: true,
+    allowReloads: false,    // SAFE DEFAULT: off
+    lastReload: 0,
+    chosenPath: null
+  };
+
+  Object.defineProperty(window, '__chatKeepalive', {
+    value: {
+      setEnabled(v){ state.enabled = !!v; schedule(); },
+      setMinutes(m){ m = Math.max(2, Math.min(30, Math.floor(m||state.minutes))); state.minutes = m; schedule(); },
+      setAutoReconnect(v){ state.autoReconnect = !!v; },
+      setAllowReloads(v){ state.allowReloads = !!v; },
+      setPingEnabled(v){ state.pingEnabled = !!v; schedule(); },
+      setRole(r){
+        state.role = (r === 'leader') ? 'leader' : 'follower';
+        state.pingEnabled = (state.role === 'leader');
+        schedule();
+      },
+      reconnectNow(){ tryClickRetry() || (state.allowReloads && softReload()); }
+    },
+    writable: false, configurable: false, enumerable: false
+  });
+
+  // Role updates from background
+  try {
+    api.runtime.onMessage.addListener((msg) => {
+      if (msg?.type === 'tgRole') {
+        try { window.__chatKeepalive?.setRole(msg.role); } catch {}
+      }
+    });
+  } catch {}
+
+  (async () => {
+    try {
+      const got = await api.storage.local.get({
+        keepaliveEnabled: true,
+        keepaliveMinutes: 4,
+        autoReconnect: true,
+        allowReloads: false
+      });
+      state.enabled = !!got.keepaliveEnabled;
+      state.minutes = Number(got.keepaliveMinutes) || 4;
+      state.autoReconnect = !!got.autoReconnect;
+      state.allowReloads = !!got.allowReloads;
+    } catch {}
+
+    // Ask background who we are. If visible and background hasn't elected yet,
+    // briefly act as leader to keep the session warm until the role message arrives.
+    try {
+      const resp = await api.runtime.sendMessage({ type: 'requestStatus' });
+      if (resp?.role) {
+        state.role = resp.role;
+        state.pingEnabled = (resp.role === 'leader');
+      } else {
+        state.pingEnabled = (document.visibilityState === 'visible');
+      }
+    } catch {
+      state.pingEnabled = (document.visibilityState === 'visible');
+    }
+
+    // If visible, nudge background to elect us leader.
+    if (document.visibilityState === 'visible') {
+      api.runtime.sendMessage({ type: 'becomeLeader' }).catch(()=>{});
+    }
+
+    schedule();
+  })();
+
+  async function pickEndpoint() {
+    const candidates = [
+      '/api/auth/session',
+      '/backend-api/models',
+      '/backend-api/conversations?offset=0&limit=1',
+      '/favicon.ico',
+      '/'
+    ];
+    for (const path of candidates) { try { if (await headOrGet(path)) return path; } catch {} }
+    return '/';
+  }
+
+  async function headOrGet(path) {
+    const url = new URL(path, location.origin).toString();
+    try {
+      const ctl = new AbortController(); const t = setTimeout(()=>ctl.abort(), 6000);
+      const res = await fetch(url, { method: 'HEAD', cache: 'no-store', credentials: 'include', keepalive: true, signal: ctl.signal });
+      clearTimeout(t);
+      return !!res && (res.ok || res.type === 'opaqueredirect');
+    } catch {}
+    try {
+      const ctl = new AbortController(); const t = setTimeout(()=>ctl.abort(), 6000);
+      const res = await fetch(url, { method: 'GET', cache: 'no-store', credentials: 'include', keepalive: true, signal: ctl.signal, mode: 'same-origin' });
+      clearTimeout(t);
+      return !!res && (res.ok || res.type === 'opaqueredirect');
+    } catch {}
+    try {
+      if (document.visibilityState !== 'visible' && 'sendBeacon' in navigator) {
+        const blob = new Blob([], { type: 'application/octet-stream' });
+        navigator.sendBeacon(url, blob);
+        return true;
+      }
+    } catch {}
+    return false;
+  }
+
+  let timer = null;
+  let visListenerAdded = false;
+
+  function schedule() {
+    if (timer) clearInterval(timer);
+    if (!state.enabled || !state.pingEnabled) return;
+
+    const base = Math.max(2, Math.min(30, state.minutes));
+    const jitter = 0.25 + Math.random() * 0.25;
+    const ms = Math.floor(base * jitter * 60000);
+    timer = setInterval(ping, ms);
+
+    if (!visListenerAdded) {
+      visListenerAdded = true;
+      document.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'visible') {
+          api.runtime.sendMessage({ type: 'becomeLeader' }).catch(()=>{});
+          if (state.role !== 'leader') { state.pingEnabled = true; schedule(); }
+          setTimeout(ping, 1200);
+        } else {
+          if (state.role !== 'leader') { state.pingEnabled = false; schedule(); }
+        }
+      }, { passive: true });
+    }
+
+    setTimeout(ping, 3000);
+  }
+
+  async function ping() {
+    if (!state.enabled || !state.pingEnabled) return;
+    if (!state.chosenPath) state.chosenPath = await pickEndpoint();
+    try { await headOrGet(state.chosenPath); tlog('ping', { role: state.role }); } catch {}
+  }
+
+  function visible() { return document.visibilityState === 'visible'; }
+  function notTyping() {
+    const ae = document.activeElement;
+    return !(ae && (ae.tagName === 'TEXTAREA' || (ae.tagName === 'INPUT' && /text|search|url|email|password/.test(ae.type||''))));
+  }
+
+  function tryClickRetry() {
+    const labels = ['reload','retry','try again','reconnect'];
+    const btns = Array.from(document.querySelectorAll('button, a[role="button"]'));
+    for (const b of btns) {
+      const t = (b.textContent||'').trim().toLowerCase();
+      if (labels.some(L => t.includes(L))) { b.click(); tlog('retryClick'); return true; }
+    }
+    return false;
+  }
+
+  function softReload() {
+    const now = Date.now();
+    if (now - state.lastReload < 30000) return;
+    if (!visible() || !notTyping()) return;
+    state.lastReload = now;
+    tlog('softReload');
+    location.reload();
+  }
+
+  const kw = /(trying to reconnect|attempting to connect|reconnecting|network error|disconnected|lost connection)/i;
+  const moErr = new MutationObserver((muts) => {
+    if (!state.autoReconnect) return;
+    for (const m of muts) for (const n of (m.addedNodes || [])) {
+      if (n.nodeType === 1) {
+        const txt = (n.textContent||'').slice(0, 4096);
+        if (kw.test(txt)) {
+          tlog('disconnect');
+          if (!tryClickRetry() && state.allowReloads) setTimeout(softReload, 2500);
+          return;
+        }
+      }
+    }
+  });
+  moErr.observe(document.documentElement || document.body, { childList: true, subtree: true });
+
+  window.addEventListener('online', () => {
+    if (state.autoReconnect && state.allowReloads) setTimeout(() => { if (!tryClickRetry()) softReload(); }, 1200);
+  });
+})();

chat-traffic-gate-leader-softcap/content/net-guard.js

@@ -0,0 +1,207 @@
+// content/net-guard.js — document_start guard with SAFE JSON thinning + safer soft-block for list pagination
+
+(() => {
+  'use strict';
+  const HOSTS = /^(chat\.openai\.com|chatgpt\.com)$/;
+  const PATHS = /(backend-api\/conversation|backend-api\/conversations|backend-api\/messages|\/history|\/messages|\/conversation|\/threads|\/graphql|\/gql|\/v1\/messages|\/v1\/threads)/i;
+  const KEEP = 60;
+
+  // Soft-block only on *list-like* pagination endpoints where an empty page is safe.
+  const SOFT_BLOCK_LIST_PATHS = /(\/backend-api\/conversations\b|\/history\b|\/threads\b|\/v1\/threads\b)/i;
+
+  const api = (typeof browser !== 'undefined') ? browser : chrome;
+  const gate = { enabled: true, intent: false, allowUntil: 0 };
+
+  const tlog = (...args) => { try { window.__tgTelemetry?.apply(null, args); } catch {} };
+
+  (async () => {
+    try {
+      const s = await api.storage.local.get({ blockHistory: true });
+      gate.enabled = !!s.blockHistory;
+    } catch {}
+    try {
+      const r = await api.runtime.sendMessage({ type: 'requestStatus' });
+      if (r) { gate.enabled = !!r.blockHistory; gate.intent = !!r.intent; gate.allowUntil = Number(r.allowUntil || 0); }
+    } catch {}
+  })();
+
+  Object.defineProperty(window, '__chatTrafficGate', {
+    value: {
+      setEnabled(v) { gate.enabled = !!v; },
+      setIntent(v) { gate.intent = !!v; },
+      allowForMs(ms) { gate.allowUntil = Date.now() + Math.max(2000, Math.min(60000, Number(ms)||10000)); }
+    },
+    writable: false, configurable: false, enumerable: false
+  });
+
+  function hasPagination(u) {
+    try {
+      const q = u.searchParams;
+      if (q.has('cursor') || q.has('before')) return true;
+      if (q.has('offset') && Number(q.get('offset')) > 0) return true;
+      if (q.has('page') && Number(q.get('page')) > 1) return true;
+      const dir = (q.get('direction') || '').toLowerCase();
+      if (/back|prev|previous/.test(dir)) return true;
+    } catch {}
+    return false;
+  }
+
+  function looksHistory(url) {
+    try {
+      const u = (typeof url === 'string') ? new URL(url, location.href) : (url instanceof URL ? url : null);
+      if (!u) return false;
+      if (!HOSTS.test(u.hostname)) return false;
+      if (!PATHS.test(u.pathname)) return false;
+      return hasPagination(u);
+    } catch { return false; }
+  }
+
+  function shouldBlock(method, url) {
+    const now = Date.now();
+    return gate.enabled && (now < gate.allowUntil ? false : !gate.intent) &&
+           (method === 'GET' || method === 'POST') && looksHistory(url);
+  }
+
+  function isSoftBlockCandidate(url) {
+    try {
+      const u = new URL(url, location.href);
+      return SOFT_BLOCK_LIST_PATHS.test(u.pathname);
+    } catch { return false; }
+  }
+
+  function softBlockResponse(url) {
+    // Generic empty page response for list-like pagination endpoints.
+    const body = JSON.stringify({ items: [], has_more: false });
+    return new Response(body, {
+      status: 200,
+      headers: { 'content-type': 'application/json; charset=utf-8' }
+    });
+  }
+
+  function thinMappingWithAncestors(data) {
+    try {
+      const mapping = data?.mapping;
+      if (!mapping || typeof mapping !== 'object') return { data, changed: false };
+      const ids = Object.keys(mapping);
+      if (ids.length <= KEEP + 10) return { data, changed: false };
+
+      const nodes = ids.map((id) => {
+        const n = mapping[id] || {};
+        const t = (n?.message?.create_time || n?.message?.create_time_ms || n?.create_time || 0);
+        return { id, t: Number(t) || 0 };
+      }).sort((a, b) => a.t - b.t);
+
+      const recent = nodes.slice(-KEEP).map(x => x.id);
+      const keepSet = new Set(recent);
+
+      // Always keep current_node chain if present.
+      const cur = data?.current_node;
+      if (typeof cur === 'string' && cur in mapping) keepSet.add(cur);
+
+      // Pull ancestor chains for all kept nodes.
+      const addAncestors = (startId) => {
+        let id = startId;
+        let guard = 0;
+        while (id && guard++ < 500) {
+          const n = mapping[id];
+          if (!n) break;
+          const p = n.parent;
+          if (!p || typeof p !== 'string') break;
+          if (keepSet.has(p)) break;
+          keepSet.add(p);
+          id = p;
+        }
+      };
+
+      for (const id of Array.from(keepSet)) addAncestors(id);
+
+      // If there is an explicit root, keep it.
+      if (typeof data?.root === 'string' && data.root in mapping) keepSet.add(data.root);
+
+      const newMap = {};
+      for (const id of keepSet) if (id in mapping) newMap[id] = mapping[id];
+      data.mapping = newMap;
+      return { data, changed: true };
+    } catch {
+      return { data, changed: false };
+    }
+  }
+
+  async function thinIfNeeded(res) {
+    try {
+      const ct = res.headers.get('content-type') || '';
+      if (!/application\/json|json/.test(ct)) return res;
+      const clone = res.clone();
+      const data = await clone.json();
+      let changed = false;
+
+      // Only thin *large* payloads to avoid breaking expectations
+      if (Array.isArray(data?.messages) && data.messages.length > KEEP + 10) {
+        data.messages.sort((a, b) => (a.create_time || 0) - (b.create_time || 0));
+        data.messages = data.messages.slice(-KEEP);
+        changed = true;
+      } else if (data?.mapping && typeof data.mapping === 'object') {
+        const out = thinMappingWithAncestors(data);
+        changed = changed || out.changed;
+      } else if (Array.isArray(data?.items) && data.items.length > KEEP + 10) {
+        data.items = data.items.slice(-KEEP);
+        changed = true;
+      }
+
+      if (!changed) return res;
+      const headers = new Headers(res.headers);
+      try { headers.delete('content-length'); } catch {}
+      if (!headers.get('content-type')) headers.set('content-type', 'application/json; charset=utf-8');
+      const body = JSON.stringify(data);
+      return new Response(body, { status: res.status, statusText: res.statusText, headers });
+    } catch {
+      return res;
+    }
+  }
+
+  const _fetch = window.fetch;
+  if (typeof _fetch === 'function') {
+    window.fetch = async function patchedFetch(input, init) {
+      try {
+        const method = ((init && init.method) || 'GET').toUpperCase();
+        const url = (input && input.url) ? input.url : String(input);
+
+        if (shouldBlock(method, url)) {
+          tlog('historyCancel');
+          // Prefer soft-block for list pagination: keeps UI calmer than an AbortError.
+          if (isSoftBlockCandidate(url)) return softBlockResponse(url);
+          const err = new DOMException('Blocked by Chat Traffic Gate', 'AbortError');
+          return Promise.reject(err);
+        }
+
+        const p = _fetch.apply(this, arguments);
+
+        // Thin only paginated history responses (when allowed)
+        if (looksHistory(url)) {
+          const res = await p;
+          return thinIfNeeded(res);
+        }
+        return p;
+      } catch {}
+      return _fetch.apply(this, arguments);
+    };
+  }
+
+  const XHR = window.XMLHttpRequest;
+  if (XHR && XHR.prototype) {
+    const _open = XHR.prototype.open, _send = XHR.prototype.send;
+    XHR.prototype.open = function(method, url) {
+      try { this.__tgMethod = String(method||'GET').toUpperCase(); this.__tgURL = url; } catch {}
+      return _open.apply(this, arguments);
+    };
+    XHR.prototype.send = function(body) {
+      try {
+        if (shouldBlock(this.__tgMethod, this.__tgURL)) {
+          try{ this.abort(); }catch{}; try{ this.dispatchEvent(new Event('error')); }catch{};
+          tlog('historyCancel'); return;
+        }
+      } catch {}
+      return _send.apply(this, arguments);
+    };
+  }
+})();

chat-traffic-gate-leader-softcap/content/traffic-ui.js

@@ -0,0 +1,106 @@
+// content/traffic-ui.js — minimal pill (fixed scope + clearer state)
+
+(function () {
+  const api = (typeof browser !== 'undefined') ? browser : chrome;
+  let status = { blockHistory: true, intent: false, allowUntil: 0 };
+
+  let pill = null;
+  let hideTimer = null;
+
+  let gateBtn = null;
+  let allow10Btn = null;
+  let ledSpan = null;
+
+  function styleBtn(b) {
+    Object.assign(b.style, {
+      padding: '4px 8px', borderRadius: '8px',
+      border: '1px solid #444', background: '#2a2a2a',
+      color: '#fff', cursor: 'pointer'
+    });
+    b.onmouseenter = () => b.style.background = '#333';
+    b.onmouseleave = () => b.style.background = '#2a2a2a';
+  }
+
+  function scheduleHide() {
+    clearTimeout(hideTimer);
+    hideTimer = setTimeout(() => { pill && (pill.style.opacity = '0.35'); }, 5000);
+  }
+
+  function ensurePill() {
+    if (pill && document.body && document.body.contains(pill)) return;
+
+    pill = document.createElement('div');
+    Object.assign(pill.style, {
+      position: 'fixed', right: '10px', bottom: '52px', zIndex: 2147483647,
+      fontFamily: 'ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, Ubuntu, Cantarell, Noto Sans, Arial',
+      fontSize: '12px', background: 'rgba(18,18,18,0.9)', color: '#fff',
+      padding: '8px 10px', borderRadius: '12px', boxShadow: '0 6px 18px rgba(0,0,0,0.35)',
+      display: 'flex', alignItems: 'center', gap: '10px', userSelect: 'none', opacity: '0.85'
+    });
+
+    ledSpan = document.createElement('span');
+    ledSpan.textContent = '🤖 Auto';
+    ledSpan.title = 'AutoPilot active';
+
+    gateBtn = document.createElement('button');
+    gateBtn.textContent = '🚦 On';
+    styleBtn(gateBtn);
+    gateBtn.title = 'Toggle network gate (AutoPilot respects this)';
+    gateBtn.addEventListener('click', async () => {
+      status.blockHistory = !status.blockHistory;
+      try { window.__chatTrafficGate?.setEnabled(status.blockHistory); } catch {}
+      try { await api.storage.local.set({ blockHistory: status.blockHistory }); } catch {}
+      try { await api.runtime.sendMessage({ type: "toggleBlockHistory", value: status.blockHistory }); } catch {}
+      render();
+    });
+
+    allow10Btn = document.createElement('button');
+    styleBtn(allow10Btn);
+    allow10Btn.textContent = 'Allow 10s';
+    allow10Btn.title = 'Temporarily allow history for 10 seconds (this tab)';
+    allow10Btn.addEventListener('click', async () => {
+      const ms = 10000;
+      try { window.__chatTrafficGate?.allowForMs(ms); } catch {}
+      try { await api.runtime.sendMessage({ type: 'allowHistoryForMs', ms }); } catch {}
+      // Optimistic local timer for UI; background is authoritative.
+      status.allowUntil = Date.now() + ms;
+      render();
+    });
+
+    pill.append(ledSpan, gateBtn, allow10Btn);
+    document.documentElement.appendChild(pill);
+
+    scheduleHide();
+    pill.addEventListener('mouseenter', () => { clearTimeout(hideTimer); pill.style.opacity = '1'; });
+    pill.addEventListener('mouseleave', scheduleHide);
+  }
+
+  function render() {
+    if (!pill || !gateBtn) return;
+    const now = Date.now();
+    const inAllow = now < (status.allowUntil || 0);
+
+    gateBtn.textContent = status.blockHistory ? '🚦 On' : '🚦 Off';
+    allow10Btn.textContent = inAllow ? `Allow ${(Math.max(0, Math.ceil((status.allowUntil - now)/1000)))}s` : 'Allow 10s';
+
+    pill.title = inAllow ? 'History temporarily allowed (timer)' : 'History blocked by default';
+    // Slight visual hint when temporarily allowed.
+    pill.style.outline = inAllow ? '1px solid rgba(120,220,120,0.65)' : 'none';
+  }
+
+  async function init() {
+    ensurePill();
+    try {
+      const resp = await api.runtime.sendMessage({ type: "requestStatus" });
+      if (resp) {
+        status.blockHistory = !!resp.blockHistory;
+        status.intent = !!resp.intent;
+        status.allowUntil = Number(resp.allowUntil || 0);
+      }
+    } catch {}
+    render();
+  }
+
+  if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', init, { once: true });
+  else init();
+})();

chat-traffic-gate-leader-softcap/manifest.json

@@ -0,0 +1,56 @@
+{
+  "manifest_version": 3,
+  "name": "Chat Traffic Gate (ChatGPT) — AutoPilot v2.2 (Safer)",
+  "version": "0.8.0",
+  "description": "Stops giant history loads at the network layer, thins large JSONs, caps DOM, keeps sessions warm — with safer defaults and fewer reconnect loops.",
+  "permissions": [
+    "storage",
+    "webRequest",
+    "webRequestBlocking",
+    "alarms",
+    "tabs"
+  ],
+  "host_permissions": [
+    "https://chat.openai.com/*",
+    "https://chatgpt.com/*"
+  ],
+  "background": {
+    "scripts": [
+      "background.js"
+    ]
+  },
+  "content_scripts": [
+    {
+      "matches": [
+        "https://chat.openai.com/*",
+        "https://chatgpt.com/*"
+      ],
+      "js": [
+        "content/early-shield.js",
+        "content/net-guard.js"
+      ],
+      "run_at": "document_start",
+      "all_frames": false
+    },
+    {
+      "matches": [
+        "https://chat.openai.com/*",
+        "https://chatgpt.com/*"
+      ],
+      "js": [
+        "content/dom-softcap.js",
+        "content/keepalive.js",
+        "content/autopilot.js",
+        "content/traffic-ui.js"
+      ],
+      "run_at": "document_idle",
+      "all_frames": false
+    }
+  ],
+  "browser_specific_settings": {
+    "gecko": {
+      "id": "chat-traffic-gate@local",
+      "strict_min_version": "109.0"
+    }
+  }
+}