Update README.md

README.md

@@ -1,162 +1,105 @@
----
-license: mit
-tags:
-  - browser-extension
-  - firefox
-  - chatgpt
-  - performance
-  - memory
----
+Chat Traffic Gate (ChatGPT) — AutoPilot v3.1 - UPDATED VERSION 
+Status
 
-# ChatGPT Traffic Gate (Firefox MV3) — AutoPilot v2.2 (Safer)
+WIP (work in progress).
+This is not perfect and still changing.
+It might help your workflow, or it might not. Use it if you want.
 
-This repo is **not a dataset** in the normal HF sense. It’s a place to host a **Firefox MV3 extension** that tries to keep ChatGPT usable when you have **lots of tabs** and/or **very long conversations**.
+I use this myself, and I notice when it is not running.
 
-## What it does (plain version)
+What this is
 
-- **Blocks “load more history” pagination requests** by default (the big ones that spike RAM / lag / churn).
-- If history pagination is allowed, it can **thin huge JSON responses** (keeps the latest chunk and the needed ancestors for ChatGPT’s conversation mapping).
-- **Soft-caps the chat DOM** by trimming old conversation turns out of the page:
-  - visible tab: keep ~60 turns
-  - hidden tab: keep ~20 turns
-  - hidden for ~10 minutes: keep ~12 turns
-- **Keeps the session warm** with low-overhead pings:
-  - **leader-only** pings from the active tab
-  - plus a low-frequency **background event-page ping** (single place, not per-tab)
-- Adds a tiny **UI pill** so you can quickly toggle the gate or temporarily allow history.
+A Firefox browser extension focused on ChatGPT tabs, built to help manage heavy/long sessions with a traffic-gating approach.
 
-This does **not** delete your chats on the server. It only changes what loads and what stays in the DOM.
+Current extension metadata and scope:
 
----
+Name: Chat Traffic Gate (ChatGPT) — AutoPilot v3.1 (Orchestrated Diagnostics)
 
-## Repo contents
+Version: 1.3.0
 
-You get the extension **two ways**:
+Manifest: v2
 
-- `chat-traffic-gate-leader-softcap/` — unpacked extension folder
-- `chat-traffic-gate-leader-softcap.zip` — the same thing, zipped
+Target sites: chat.openai.com and chatgpt.com 
 
-Inside the folder:
+manifest
 
-- `manifest.json` — MV3 manifest (Firefox)
-- `background.js` — request gating + leader/follower role assignment + background alarm ping
-- `content/early-shield.js` — briefly hides turns at page start, then unshields
-- `content/net-guard.js` — patches `fetch` + XHR at `document_start` to block pagination and (when allowed) thin big JSON
-- `content/dom-softcap.js` — trims old conversation turns out of the DOM (changes based on tab visibility)
-- `content/keepalive.js` — leader-only keepalive pings + reconnect helper (reloads OFF by default)
-- `content/autopilot.js` — visible-tab tuning (intent detection + adjusts keepalive/softcap if things look bad)
-- `content/traffic-ui.js` — UI pill (“🚦 On/Off” + “Allow 10s”)
+What is currently included
 
----
+Content scripts are split by load phase:
 
-## Install (fast / lazy)
+At document_start:
 
-### Option A — load unpacked folder (recommended)
-1. Download `chat-traffic-gate-leader-softcap.zip` from this repo and unzip it.
-2. In Firefox, open: `about:debugging#/runtime/this-firefox`
-3. Click **Load Temporary Add-on…**
-4. Select the **`manifest.json`** inside the unzipped folder.
+content/core-utils.js
 
-Temporary addons disappear when Firefox restarts (that’s normal).
+content/early-shield.js
 
-### Option B — use the unpacked folder in the repo
-Same process as above, but download the folder contents and point Firefox at `manifest.json`.
+content/net-guard.js
 
----
+At document_idle:
 
-## How the “history gate” works
+content/core-utils.js
 
-### Background layer (webRequest)
-`background.js` uses `webRequestBlocking` to cancel only **true pagination** requests:
-- it looks for query params like `cursor`, `before`, `offset>0`, `page>1`, or backward direction markers
-- it only applies to “history-like” endpoints
-- it avoids blanket blocking (session and models endpoints are allow-listed)
+content/dom-softcap.js
 
-### Page layer (fetch/XHR patch)
-`content/net-guard.js` runs at `document_start` and patches:
-- `window.fetch`
-- `XMLHttpRequest`
+content/keepalive.js
 
-If a request is a paginated history load **and** you didn’t indicate intent:
-- some list endpoints get a **safe empty page JSON** (soft-block)
-- others get an AbortError / aborted XHR (hard-block)
+content/autopilot.js
 
-### Intent + temporary allow
-The extension decides “intent” mostly from **scroll behavior**:
-- near the top, or scrolling upward recently → intent = true
-- otherwise intent = false
+content/traffic-ui.js 
 
-You can also force allow pagination for a short window:
-- UI pill: **Allow 10s**
-- programmatic: `__chatTrafficGate.allowForMs(10000)`
+manifest
 
----
+Background script:
 
-## JSON thinning (what it actually does)
+background.js (non-persistent background) 
 
-Only when a request is a **paginated history request** (the same pagination detection as above), it may thin JSON:
-- if `messages[]` is huge → keep the newest ~60
-- if `items[]` is huge → keep the newest ~60
-- if ChatGPT’s `mapping{}` is huge → keep the newest ~60 nodes **plus ancestors** (and keep `current_node` / `root` when present)
+manifest
 
-Goal: reduce payload size while keeping the mapping structurally coherent.
+Permissions
 
----
+The manifest currently requests:
 
-## DOM soft-cap (memory control)
+storage
 
-The softcap script trims old turn nodes from the DOM using:
+webRequest
 
-- selector: `[data-testid^="conversation-turn-"]`
+alarms
 
-It tries to keep the UI stable by:
-- trimming in batches
-- briefly hiding the container while trimming to reduce layout thrash
-- unshielding the early CSS shield once the first trim completes
+tabs
 
----
+notifications
 
-## Keepalive + reconnect behavior
+Site access for https://chat.openai.com/* and https://chatgpt.com/* 
 
-### Leader-only pings
-Only the **active tab** is intended to be “leader” and run keepalive pings. Background assigns roles and tells tabs to switch.
+manifest
 
-### Endpoints it tries
-It probes a small set and sticks with the first one that works, e.g.:
-- `/api/auth/session`
-- `/backend-api/models`
-- `/backend-api/conversations?offset=0&limit=1`
-- `/favicon.ico`
-- `/`
+Browser target
 
-### Reconnect helper
-It watches the DOM for text like “reconnecting / disconnected / network error” and tries:
-- click buttons with text like “Retry / Reconnect / Try again”
-- **reload is OFF by default** (AutoPilot may enable it temporarily if disconnects are bad)
+This build includes Gecko settings with:
 
----
+Extension ID: chat-traffic-gate@local
 
-## UI controls
+strict_min_version: 109.0 
 
-A small pill appears on the page:
+manifest
 
-- **🚦 On / Off**: toggles history gating
-- **Allow 10s**: allows pagination for 10 seconds in that tab
+Install (Firefox, temporary load)
 
----
+Download/clone this repo.
 
-## Dev / power-user globals
+Open Firefox and go to about:debugging#/runtime/this-firefox
 
-These are intentionally exposed by the scripts:
+Click Load Temporary Add-on
 
-```js
-__chatTrafficGate.setEnabled(true|false)
-__chatTrafficGate.setIntent(true|false)
-__chatTrafficGate.allowForMs(10000)
+Select manifest.json
 
-__chatSoftCap.setConfig({ enabled: true, keep: 60, keepHidden: 20, keepDeepHidden: 12 })
+Reality check
+
+This is a personal tool and actively being worked on.
+
+It is not a promise, not polished, and not guaranteed.
+
+It may help some users, and do nothing for others.
+
+If it helps you, great. If not, skip it.
 
-__chatKeepalive.setMinutes(4)
-__chatKeepalive.setAutoReconnect(true)
-__chatKeepalive.setAllowReloads(false)
-__chatKeepalive.reconnectNow()