Upload 9 files

UPDATED VERSION

GPTTrafficgateUPDATEDv3.1/background.js

@@ -0,0 +1,1035 @@
+// background.js — orchestrator-owned notifications, retries, ledger, and global budget
+// Updated: v3.2 big-pass freshness contract + detector telemetry + bounded orch events
+// Patch: v3.2.1 signal compatibility (freshnessTs/detectedReply) + stronger freshness normalization
+// Patch: v3.2.2 popup-only notifications (hard mute; background-enforced silent meta)
+// Patch: v3.2.3 reliability fix (cooldown queues detected replies + Firefox notify availability hardening)
+// Patch: v3.2.4 pulse-compat hardening (detectedReplyPulse + signal ts fallback + cooldown accounting)
+// Patch: v3.2.5 queue/freshness hardening (pulse fallback detectedTs + queue age telemetry + depth normalization)
+const api = (typeof browser !== 'undefined') ? browser : chrome;
+
+const BUILD_META = Object.freeze({
+  channel: 'local-temp-addon',
+  buildTag: 'v3.2.5-orchestrated-freshness-pulse-compat-silent-popup-reliable-detected-queue-age',
+  buildTs: '2026-02-13T22:15:00Z',
+  contract: 'tgReplyDetected.v3'
+});
+
+const GPT_URLS = ['https://chat.openai.com/*', 'https://chatgpt.com/*'];
+const GPT_HOST_RE = /^(chat\.openai\.com|chatgpt\.com)$/;
+
+let cfg = { blockHistory: true, debug: false };
+const intent = new Map();       // tabId -> bool
+const allowUntil = new Map();   // tabId -> ms timestamp
+let leaderTabId = null;
+
+/* ---------------------------
+ * Orchestrator + health model
+ * -------------------------- */
+const orch = {
+  peers: new Map(), // tabId -> { ts, visible, streaming, pressure, role, seq, lastSignalTs, lastDetectedTs, lastStreamEndTs, detectorMisses, freshKind }
+  limits: { maxVisibleStreamers: 1, maxTotalStreamers: 2 },
+  events: [], // bounded diagnostics ring
+  health: {
+    // traffic
+    signals: 0,
+    detected_received: 0,
+    detected_accepted: 0,
+    detected_dropped: 0,
+
+    // drop reasons
+    dropped_invalid_payload: 0,
+    dropped_duplicate: 0,
+    dropped_cooldown: 0,
+    dropped_notifications_unavailable: 0,
+
+    // notify lifecycle
+    enqueued: 0,
+    sent: 0,
+    failed: 0,
+    fallback: 0,
+
+    // freshness / contract fields
+    lastSignalTs: 0,
+    lastDetectedTs: 0,
+    lastAcceptedTs: 0,
+    lastOkTs: 0,
+    lastStreamEndTs: 0,
+
+    // extra diagnostics
+    lastEventId: '',
+    lastNotifyVia: '',
+    lastSeenFreshKind: '',
+    detectorMisses: 0,
+    lastSignalAgeMs: 0,
+    lastDetectedAgeMs: 0
+  }
+};
+
+const notifyState = {
+  requested: 0,
+  sent: 0,
+  failed: 0,
+  retried: 0,
+  fallback: 0,
+  suppressed: 0,
+  queueDepth: 0,
+  lastError: '',
+  lastNotifyAt: 0,
+  lastEventId: '',
+  lastNotifyVia: ''
+};
+
+const runtimeConfig = {
+  notifyCooldownMs: 7000,
+  detectDedupeMs: 45000,
+  queueTtlMs: 180000,
+  maxQueue: 200,
+  maxLedger: 300,
+  maxRetry: 1,
+  maxOrchEvents: 400,
+
+  // Hard policy: popup notifications only; never sound from background.
+  forceSilentNotifications: true
+};
+
+const recentEventIds = new Map(); // eventId -> ts
+let notifyQueue = [];             // {eventId,title,message,ts,retries,lastErr,source}
+let notifyLedger = [];            // compact notify history
+
+function logDbg(...args) {
+  try {
+    if (cfg.debug) console.log('[TrafficGate BG]', ...args);
+  } catch {}
+}
+
+function ageMs(ts) {
+  if (!ts || !Number.isFinite(ts)) return null;
+  return Math.max(0, Date.now() - ts);
+}
+
+function updateHealthAges() {
+  orch.health.lastSignalAgeMs = ageMs(orch.health.lastSignalTs) || 0;
+  orch.health.lastDetectedAgeMs = ageMs(orch.health.lastDetectedTs) || 0;
+}
+
+function queueAges() {
+  if (!notifyQueue.length) return { oldestAgeMs: 0, newestAgeMs: 0 };
+  const now = Date.now();
+  const ages = notifyQueue
+    .map((q) => ageMs(Number(q?.ts || 0)) || 0)
+    .filter((n) => Number.isFinite(n) && n >= 0);
+  if (!ages.length) return { oldestAgeMs: 0, newestAgeMs: 0 };
+  return {
+    oldestAgeMs: Math.max(...ages),
+    newestAgeMs: Math.min(...ages)
+  };
+}
+
+function updateQueueDepth() {
+  notifyState.queueDepth = notifyQueue.length;
+}
+
+function recordOrchEvent(kind, data) {
+  try {
+    const evt = {
+      ts: Date.now(),
+      kind: String(kind || 'unknown'),
+      ...(data || {})
+    };
+    orch.events.push(evt);
+    if (orch.events.length > runtimeConfig.maxOrchEvents) {
+      orch.events.splice(0, orch.events.length - runtimeConfig.maxOrchEvents);
+    }
+  } catch {}
+}
+
+function logNotify(evt) {
+  try {
+    notifyLedger.push({ ts: Date.now(), ...evt });
+    if (notifyLedger.length > runtimeConfig.maxLedger) {
+      notifyLedger.splice(0, notifyLedger.length - runtimeConfig.maxLedger);
+    }
+  } catch {}
+}
+
+function pruneRecentEventIds() {
+  const now = Date.now();
+  for (const [id, ts] of recentEventIds.entries()) {
+    if ((now - ts) > runtimeConfig.detectDedupeMs) recentEventIds.delete(id);
+  }
+}
+
+function eventSeenRecently(eventId) {
+  pruneRecentEventIds();
+  if (!eventId) return false;
+  return recentEventIds.has(eventId);
+}
+
+function markEventSeen(eventId) {
+  if (!eventId) return;
+  recentEventIds.set(eventId, Date.now());
+}
+
+function prunePeers() {
+  const now = Date.now();
+  for (const [id, st] of orch.peers.entries()) {
+    if (!st || (now - (st.ts || 0)) > 30000) orch.peers.delete(id);
+  }
+}
+
+function computeGlobalBudget() {
+  prunePeers();
+  let total = 0;
+  let visible = 0;
+  for (const st of orch.peers.values()) {
+    if (st?.streaming) {
+      total += 1;
+      if (st.visible) visible += 1;
+    }
+  }
+  return {
+    totalStreamers: total,
+    visibleStreamers: visible,
+    followerHold: (visible > orch.limits.maxVisibleStreamers) || (total > orch.limits.maxTotalStreamers)
+  };
+}
+
+async function broadcastBudget() {
+  const budget = computeGlobalBudget();
+  try {
+    const tabs = await api.tabs.query({ url: GPT_URLS });
+    for (const t of (tabs || [])) {
+      if (typeof t.id === 'number') {
+        api.tabs.sendMessage(t.id, { type: 'tgGlobalBudget', budget }).catch(() => {});
+      }
+    }
+  } catch {}
+}
+
+setInterval(() => {
+  updateHealthAges();
+  broadcastBudget().catch(() => {});
+}, 3000);
+
+async function canUseNotifications() {
+  try {
+    // Reliability rule:
+    // If notifications API exists, attempt create() and handle failures there.
+    // Avoid permissions.contains false-negatives (seen in Firefox contexts).
+    return !!(api.notifications && api.notifications.create);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Normalize/strip any sound-related fields carried in from upstream.
+ * Background stays popup-only.
+ */
+function normalizeNotifyMeta(meta) {
+  const inMeta = (meta && typeof meta === 'object') ? meta : {};
+  const normalized = {
+    eventId: String(inMeta.eventId || ''),
+    via: String(inMeta.via || 'unknown'),
+    source: String(inMeta.source || 'unknown'),
+
+    // hard mute contract
+    silent: true,
+    sound: false,
+    playSound: false,
+    beep: false,
+    audio: false
+  };
+
+  if (!runtimeConfig.forceSilentNotifications) {
+    // reserved path if policy is changed later
+    normalized.silent = !!inMeta.silent;
+    normalized.sound = !!inMeta.sound;
+    normalized.playSound = !!inMeta.playSound;
+    normalized.beep = !!inMeta.beep;
+    normalized.audio = !!inMeta.audio;
+  }
+
+  return normalized;
+}
+
+async function sendUserNotification(title, message, meta) {
+  const now = Date.now();
+  const metaNorm = normalizeNotifyMeta(meta);
+
+  if ((now - notifyState.lastNotifyAt) < runtimeConfig.notifyCooldownMs) {
+    notifyState.suppressed += 1;
+    recordOrchEvent('notify_suppressed_cooldown', {
+      eventId: metaNorm.eventId || '',
+      via: metaNorm.via || '',
+      silent: !!metaNorm.silent
+    });
+    return { ok: false, reason: 'cooldown' };
+  }
+
+  const canNotify = await canUseNotifications();
+  if (!canNotify) {
+    notifyState.failed += 1;
+    notifyState.lastError = 'notifications_unavailable';
+    orch.health.dropped_notifications_unavailable += 1;
+    orch.health.lastNotifyVia = String(metaNorm.via || 'unknown');
+    recordOrchEvent('notify_unavailable', {
+      eventId: metaNorm.eventId || '',
+      via: metaNorm.via || '',
+      silent: !!metaNorm.silent
+    });
+    return { ok: false, reason: 'notifications_unavailable' };
+  }
+
+  try {
+    const t = String(title || 'ChatGPT');
+    const m = String(message || '');
+
+    const id = `tg_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    await api.notifications.create(id, {
+      type: 'basic',
+      iconUrl:
+        'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAABHUlEQVR4nKWTvUoDQRSGv5mQpI0Q6QWFrY2FhY2Nha2VhY2NrY2FrY2FjY2NjY2FhY2Nha2NhY2FjY2Nha2N7M7M7uQ9+8w3fOec8B0rA2j5fM7cR9G3fA2t4E7t8AqYQ6iJmB3C8L8mC6aKQ3v4C2n0Q4S6n3dD1hQWq0cQz8q0j1NQF3n3m0vNq4D+L7aB2r8mV1wA0x9k2xD7i4GgLxq2y0Xq4Qz6QmM3d8s9Fv3qkzqfI4nWQb6h9B9m5m2o1oH0H8f4x8B8u7Q6C2tJQmK6Y7n5xwC9m2m6y8g5QvQf4Qq7m9mR1Q8j4gX7aGJ9Rz3m2m2QxkP0Hk8W2n3y0D8k1m1m6rj8g3wTj7QAAAABJRU5ErkJggg==',
+      title: t,
+      message: m
+    });
+
+    notifyState.sent += 1;
+    notifyState.lastNotifyAt = now;
+    notifyState.lastEventId = String(metaNorm.eventId || '');
+    notifyState.lastNotifyVia = String(metaNorm.via || 'unknown');
+
+    orch.health.sent += 1;
+    orch.health.lastOkTs = now;
+    orch.health.lastEventId = String(metaNorm.eventId || '');
+    orch.health.lastNotifyVia = String(metaNorm.via || 'unknown');
+
+    recordOrchEvent('notify_sent', {
+      eventId: metaNorm.eventId || '',
+      via: metaNorm.via || '',
+      source: metaNorm.source || '',
+      silent: !!metaNorm.silent
+    });
+
+    return { ok: true, reason: 'sent', id };
+  } catch (e) {
+    notifyState.failed += 1;
+    notifyState.lastError = String(e?.message || e || 'notify_exception');
+
+    orch.health.failed += 1;
+    orch.health.lastEventId = String(metaNorm.eventId || '');
+    orch.health.lastNotifyVia = String(metaNorm.via || 'unknown');
+
+    recordOrchEvent('notify_fail', {
+      eventId: metaNorm.eventId || '',
+      via: metaNorm.via || '',
+      source: metaNorm.source || '',
+      err: notifyState.lastError,
+      silent: !!metaNorm.silent
+    });
+
+    return { ok: false, reason: 'exception' };
+  }
+}
+
+function enqueueNotify(item) {
+  notifyQueue.push(item);
+  if (notifyQueue.length > runtimeConfig.maxQueue) {
+    notifyQueue.splice(0, notifyQueue.length - runtimeConfig.maxQueue);
+  }
+  updateQueueDepth();
+}
+
+function normalizeReplyDetectionPayload(msg, tabId) {
+  const eventIdRaw = (msg && typeof msg.eventId === 'string') ? msg.eventId.trim() : '';
+  const sourceRaw = (msg && typeof msg.source === 'string') ? msg.source.trim() : '';
+  const titleRaw = (msg && typeof msg.title === 'string') ? msg.title.trim() : 'ChatGPT';
+  const messageRaw = (msg && typeof msg.message === 'string') ? msg.message.trim() : 'Reply ready in another tab';
+  const roleHintRaw = (msg && typeof msg.roleHint === 'string') ? msg.roleHint.trim() : '';
+
+  const detectedTs = Number(msg?.detectedTs || 0);
+  const streamEndTs = Number(msg?.streamEndTs || 0);
+
+  const normalized = {
+    eventId: eventIdRaw || `evt_${Date.now()}_${tabId || 'na'}_${Math.random().toString(36).slice(2, 6)}`,
+    source: sourceRaw || 'unknown',
+    title: titleRaw || 'ChatGPT',
+    message: messageRaw || 'Reply ready in another tab',
+    roleHint: roleHintRaw || '',
+    detectedTs: Number.isFinite(detectedTs) && detectedTs > 0 ? detectedTs : Date.now(),
+    streamEndTs: Number.isFinite(streamEndTs) && streamEndTs > 0 ? streamEndTs : 0
+  };
+
+  const valid =
+    typeof normalized.eventId === 'string' &&
+    normalized.eventId.length >= 6 &&
+    typeof normalized.title === 'string' &&
+    normalized.title.length > 0 &&
+    typeof normalized.message === 'string' &&
+    normalized.message.length > 0 &&
+    typeof normalized.source === 'string' &&
+    normalized.source.length > 0;
+
+  return { valid, normalized };
+}
+
+function normalizeFreshKind(msg) {
+  const fk = String(msg?.freshKind || msg?.freshnessKind || '').trim();
+  if (fk) return fk;
+  return 'heartbeat';
+}
+
+function hasDetectedPulse(msg) {
+  return msg?.detectedReply === true || msg?.detectedReplyPulse === true || msg?.pulseDetected === true;
+}
+
+function normalizeSignalTs(msg) {
+  const raw = Number(msg?.lastSignalTs || msg?.freshnessTs || 0);
+  if (Number.isFinite(raw) && raw > 0) return raw;
+  return Date.now();
+}
+
+function normalizeDetectedTs(msg) {
+  const d = Number(msg?.lastDetectedTs || 0);
+  if (Number.isFinite(d) && d > 0) return d;
+
+  const se = Number(msg?.lastStreamEndTs || 0);
+  if (Number.isFinite(se) && se > 0) return se;
+
+  return normalizeSignalTs(msg);
+}
+
+function absorbFreshnessFromSignal(msg) {
+  const msgSignalTs = normalizeSignalTs(msg);
+  const msgDetectedTs = Number(msg?.lastDetectedTs || 0);
+  const msgStreamEndTs = Number(msg?.lastStreamEndTs || 0);
+  const msgDetectorMisses = Number(msg?.detectorMisses || 0);
+  const msgFreshKind = normalizeFreshKind(msg);
+
+  orch.health.lastSignalTs = Math.max(orch.health.lastSignalTs || 0, msgSignalTs);
+
+  if (Number.isFinite(msgDetectedTs) && msgDetectedTs > 0) {
+    orch.health.lastDetectedTs = Math.max(orch.health.lastDetectedTs || 0, msgDetectedTs);
+  }
+  if (Number.isFinite(msgStreamEndTs) && msgStreamEndTs > 0) {
+    orch.health.lastStreamEndTs = Math.max(orch.health.lastStreamEndTs || 0, msgStreamEndTs);
+  }
+  if (Number.isFinite(msgDetectorMisses) && msgDetectorMisses >= 0) {
+    orch.health.detectorMisses = Math.max(orch.health.detectorMisses || 0, msgDetectorMisses);
+  }
+  if (msgFreshKind) {
+    orch.health.lastSeenFreshKind = msgFreshKind;
+  }
+
+  // optional pulse path from heartbeat producer
+  if (hasDetectedPulse(msg)) {
+    orch.health.detected_received += 1;
+    const pulseTs = normalizeDetectedTs(msg);
+    orch.health.lastDetectedTs = Math.max(orch.health.lastDetectedTs || 0, pulseTs || Date.now());
+    orch.health.lastAcceptedTs = Date.now();
+
+    if (notifyQueue.length > 0) {
+      const qa = queueAges();
+      recordOrchEvent('queue_detected_pulse', {
+        via: 'signal',
+        depth: notifyQueue.length,
+        oldestAgeMs: qa.oldestAgeMs,
+        newestAgeMs: qa.newestAgeMs,
+        freshKind: msgFreshKind || ''
+      });
+    }
+
+    recordOrchEvent('detected_pulse', {
+      via: 'signal',
+      freshKind: msgFreshKind || '',
+      detectorMisses: Number(msgDetectorMisses || 0),
+      pulseTs
+    });
+  }
+}
+
+async function handleReplyDetected(msg, tabId) {
+  orch.health.detected_received += 1;
+  orch.health.lastDetectedTs = Date.now();
+
+  recordOrchEvent('detected_received', {
+    tabId,
+    eventId: String(msg?.eventId || ''),
+    source: String(msg?.source || '')
+  });
+
+  const { valid, normalized } = normalizeReplyDetectionPayload(msg, tabId);
+
+  if (!valid) {
+    orch.health.detected_dropped += 1;
+    orch.health.dropped_invalid_payload += 1;
+
+    logNotify({ via: 'detected', ok: false, reason: 'invalid_payload', raw: String(msg?.eventId || '') });
+    recordOrchEvent('detected_invalid', { tabId, rawEventId: String(msg?.eventId || '') });
+
+    return { ok: false, dropped: 'invalid_payload', budget: computeGlobalBudget() };
+  }
+
+  orch.health.lastEventId = normalized.eventId;
+  orch.health.lastDetectedTs = normalized.detectedTs || Date.now();
+  if (normalized.streamEndTs) {
+    orch.health.lastStreamEndTs = Math.max(orch.health.lastStreamEndTs || 0, normalized.streamEndTs);
+  }
+
+  if (eventSeenRecently(normalized.eventId)) {
+    orch.health.detected_dropped += 1;
+    orch.health.dropped_duplicate += 1;
+
+    logNotify({ via: 'detected', eventId: normalized.eventId, ok: false, reason: 'duplicate' });
+    recordOrchEvent('detected_duplicate', { tabId, eventId: normalized.eventId });
+
+    return { ok: false, dropped: 'duplicate', eventId: normalized.eventId, budget: computeGlobalBudget() };
+  }
+
+  markEventSeen(normalized.eventId);
+
+  const sendRes = await sendUserNotification(normalized.title, normalized.message, normalizeNotifyMeta({
+    eventId: normalized.eventId,
+    via: 'detected',
+    source: normalized.source
+  }));
+
+  notifyState.requested += 1;
+  orch.health.lastAcceptedTs = Date.now();
+  orch.health.detected_accepted += 1;
+
+  if (sendRes.ok) {
+    logNotify({ via: 'detected', eventId: normalized.eventId, ok: true, reason: 'sent', source: normalized.source, silent: true });
+    return { ok: true, eventId: normalized.eventId, sent: true, budget: computeGlobalBudget() };
+  }
+
+  // Reliability change: do NOT drop detected events on cooldown.
+  // Queue them so completion notifications are eventually delivered.
+  if (sendRes.reason === 'cooldown') {
+    notifyState.fallback += 1;
+    orch.health.fallback += 1;
+    orch.health.detected_dropped += 1;
+    orch.health.dropped_cooldown += 1;
+
+    enqueueNotify({
+      eventId: normalized.eventId,
+      title: normalized.title,
+      message: normalized.message,
+      source: normalized.source,
+      ts: Date.now(),
+      retries: 0,
+      lastErr: 'cooldown'
+    });
+
+    orch.health.enqueued += 1;
+    const qa = queueAges();
+    logNotify({ via: 'detected', eventId: normalized.eventId, ok: false, reason: 'queued_cooldown', silent: true });
+    recordOrchEvent('detected_enqueued_cooldown', {
+      tabId,
+      eventId: normalized.eventId,
+      depth: notifyQueue.length,
+      oldestAgeMs: qa.oldestAgeMs,
+      newestAgeMs: qa.newestAgeMs
+    });
+
+    return { ok: false, queued: true, dropped: 'cooldown', eventId: normalized.eventId, budget: computeGlobalBudget() };
+  }
+
+  enqueueNotify({
+    eventId: normalized.eventId,
+    title: normalized.title,
+    message: normalized.message,
+    source: normalized.source,
+    ts: Date.now(),
+    retries: 0,
+    lastErr: sendRes.reason || 'unknown'
+  });
+
+  orch.health.enqueued += 1;
+  const qa = queueAges();
+  logNotify({ via: 'detected', eventId: normalized.eventId, ok: false, reason: 'queued', err: sendRes.reason || '', silent: true });
+  recordOrchEvent('detected_enqueued', {
+    tabId,
+    eventId: normalized.eventId,
+    err: sendRes.reason || '',
+    depth: notifyQueue.length,
+    oldestAgeMs: qa.oldestAgeMs,
+    newestAgeMs: qa.newestAgeMs
+  });
+
+  return { ok: false, queued: true, eventId: normalized.eventId, budget: computeGlobalBudget() };
+}
+
+async function drainNotifyQueue() {
+  const now = Date.now();
+  const keep = [];
+
+  for (const item of notifyQueue) {
+    if (!item || !item.title) continue;
+    if ((now - (item.ts || now)) > runtimeConfig.queueTtlMs) {
+      recordOrchEvent('queue_drop_ttl', { eventId: item?.eventId || '' });
+      continue;
+    }
+
+    const sendRes = await sendUserNotification(item.title, item.message || '', normalizeNotifyMeta({
+      eventId: item.eventId || '',
+      via: 'queue-drain',
+      source: item.source || ''
+    }));
+
+    if (sendRes.ok) {
+      logNotify({ via: 'queue-drain', eventId: item.eventId || '', ok: true, silent: true });
+      continue;
+    }
+
+    if ((item.retries || 0) < runtimeConfig.maxRetry) {
+      item.retries = (item.retries || 0) + 1;
+      item.lastErr = sendRes.reason || 'retry_failed';
+      notifyState.retried += 1;
+      keep.push(item);
+
+      logNotify({ via: 'queue-drain', eventId: item.eventId || '', ok: false, reason: 'retry', err: item.lastErr, silent: true });
+      recordOrchEvent('queue_retry', {
+        eventId: item.eventId || '',
+        retries: item.retries,
+        err: item.lastErr
+      });
+    } else {
+      notifyState.fallback += 1;
+      orch.health.fallback += 1;
+      logNotify({ via: 'queue-drain', eventId: item.eventId || '', ok: false, reason: 'fallback', err: sendRes.reason || '', silent: true });
+      recordOrchEvent('queue_drop_fallback', {
+        eventId: item.eventId || '',
+        err: sendRes.reason || ''
+      });
+    }
+  }
+
+  notifyQueue = keep.slice(-50);
+  updateQueueDepth();
+}
+
+setInterval(() => {
+  drainNotifyQueue().catch(() => {});
+}, 15000);
+
+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;
+
+    if (typeof oldLeader === 'number') {
+      api.tabs.sendMessage(oldLeader, { type: 'tgRole', role: 'follower' }).catch(() => {});
+    }
+    if (typeof leaderTabId === 'number') {
+      api.tabs.sendMessage(leaderTabId, { type: 'tgRole', role: 'leader' }).catch(() => {});
+    }
+  } catch {}
+}
+
+// Wake the event page periodically (Firefox MV2/MV3 mixed behavior resilience)
+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 {}
+  await setLeader(null);
+})();
+
+api.storage.onChanged.addListener((changes, area) => {
+  if (area !== 'local') return;
+  if (changes.blockHistory) cfg.blockHistory = !!changes.blockHistory.newValue;
+  if (changes.debug) cfg.debug = !!changes.debug.newValue;
+});
+
+// Cleanup per-tab state
+try {
+  api.tabs?.onRemoved?.addListener((tabId) => {
+    try { intent.delete(tabId); } catch {}
+    try { allowUntil.delete(tabId); } catch {}
+    try { orch.peers.delete(tabId); } catch {}
+    if (leaderTabId === tabId) {
+      leaderTabId = null;
+      setLeader(null);
+    }
+  });
+
+  api.tabs?.onUpdated?.addListener((tabId, changeInfo, tab) => {
+    try {
+      if (!changeInfo) return;
+
+      if (changeInfo.url && !isGptUrl(changeInfo.url)) {
+        intent.delete(tabId);
+        allowUntil.delete(tabId);
+        orch.peers.delete(tabId);
+        if (leaderTabId === tabId) {
+          leaderTabId = null;
+          setLeader(null);
+        }
+      }
+
+      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 {}
+
+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;
+
+    await bgPingOnce('https://chatgpt.com/api/auth/session');
+    await bgPingOnce('https://chat.openai.com/api/auth/session');
+  });
+} catch {}
+
+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();
+
+    if (/\/api\/auth\/session$/.test(p)) return false;
+    if (/\/backend-api\/models$/.test(p)) return false;
+
+    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;
+
+    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 {}
+
+function makeHealthSnapshot() {
+  updateHealthAges();
+  const budget = computeGlobalBudget();
+  const qAges = queueAges();
+
+  const healthOut = {
+    ...orch.health,
+    // explicit freshness ages (for panel)
+    lastSignalAgeMs: ageMs(orch.health.lastSignalTs) || 0,
+    lastDetectedAgeMs: ageMs(orch.health.lastDetectedTs) || 0,
+    lastAcceptedAgeMs: ageMs(orch.health.lastAcceptedTs) || 0,
+    lastNotifyOkAgeMs: ageMs(orch.health.lastOkTs) || 0
+  };
+
+  return {
+    ok: true,
+    build: BUILD_META,
+    stats: { ...notifyState },
+    queue: notifyQueue.length,
+    queueOldestAgeMs: qAges.oldestAgeMs,
+    queueNewestAgeMs: qAges.newestAgeMs,
+    last: notifyLedger.slice(-20),
+    orchestration: {
+      health: healthOut,
+      budget,
+      peers: orch.peers.size
+    },
+    freshness: {
+      lastSignalAgo: healthOut.lastSignalAgeMs,
+      lastDetectedAgo: healthOut.lastDetectedAgeMs,
+      lastAcceptedAgo: healthOut.lastAcceptedAgeMs,
+      lastNotifyOkAgo: healthOut.lastNotifyOkAgeMs
+    }
+  };
+}
+
+function makeDiagnostics() {
+  return {
+    ok: true,
+    build: BUILD_META,
+    cfg: { ...cfg },
+    runtimeConfig: { ...runtimeConfig },
+    leaderTabId,
+    intentSize: intent.size,
+    allowUntilSize: allowUntil.size,
+    peerIds: Array.from(orch.peers.keys()).slice(-50),
+    recentEventIds: Array.from(recentEventIds.keys()).slice(-50),
+    queueDepth: notifyQueue.length,
+    ledgerTail: notifyLedger.slice(-40),
+    orchEventsTail: orch.events.slice(-80),
+    health: makeHealthSnapshot()
+  };
+}
+
+api.runtime.onMessage.addListener((msg, sender) => {
+  const tabId = sender?.tab?.id;
+  // non-tab commands allowed
+  const hasTab = typeof tabId === 'number';
+
+  try {
+    if (msg?.type === 'tgGetBuildInfo') {
+      return Promise.resolve({ ok: true, build: BUILD_META });
+    }
+
+    if (msg?.type === 'tgDiagnostics') {
+      return Promise.resolve(makeDiagnostics());
+    }
+
+    if (msg?.type === 'tgNotifyHealth') {
+      return Promise.resolve(makeHealthSnapshot());
+    }
+
+    if (msg?.type === 'tgGetOrchEvents') {
+      const lim = Math.max(1, Math.min(300, Number(msg?.limit || 80)));
+      return Promise.resolve({ ok: true, events: orch.events.slice(-lim), build: BUILD_META });
+    }
+
+    if (!hasTab) return;
+
+    if (msg?.type === 'historyIntent') {
+      intent.set(tabId, !!msg.value);
+      return;
+    }
+
+    if (msg?.type === 'toggleBlockHistory') {
+      cfg.blockHistory = !!msg.value;
+      api.storage.local.set({ blockHistory: cfg.blockHistory });
+      return;
+    }
+
+    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,
+        build: BUILD_META
+      });
+    }
+
+    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);
+      return Promise.resolve({ ok: true, until });
+    }
+
+    if (msg?.type === 'becomeLeader') {
+      setLeader(tabId);
+      return Promise.resolve({ ok: true });
+    }
+
+    if (msg?.type === 'tgSignal') {
+      orch.health.signals += 1;
+      orch.health.lastSignalTs = Date.now();
+
+      absorbFreshnessFromSignal(msg);
+      updateHealthAges();
+
+      const peer = {
+        ts: Date.now(),
+        visible: !!msg.visible,
+        streaming: !!msg.streaming,
+        pressure: Number(msg.pressure || 0),
+        role: String(msg.role || 'follower'),
+        seq: Number(msg.seq || 0),
+
+        lastSignalTs: normalizeSignalTs(msg),
+        lastDetectedTs: normalizeDetectedTs(msg),
+        lastStreamEndTs: Number(msg.lastStreamEndTs || 0),
+        detectorMisses: Number(msg.detectorMisses || 0),
+        freshKind: normalizeFreshKind(msg)
+      };
+
+      orch.peers.set(tabId, peer);
+
+      if (peer.detectorMisses > 0) {
+        orch.health.detectorMisses = Math.max(orch.health.detectorMisses || 0, peer.detectorMisses);
+      }
+      if (peer.lastStreamEndTs > 0) {
+        orch.health.lastStreamEndTs = Math.max(orch.health.lastStreamEndTs || 0, peer.lastStreamEndTs);
+      }
+      if (peer.lastDetectedTs > 0) {
+        orch.health.lastDetectedTs = Math.max(orch.health.lastDetectedTs || 0, peer.lastDetectedTs);
+      }
+      if (peer.freshKind) {
+        orch.health.lastSeenFreshKind = peer.freshKind;
+      }
+
+      recordOrchEvent('signal', {
+        tabId,
+        visible: peer.visible ? 1 : 0,
+        streaming: peer.streaming ? 1 : 0,
+        pressure: peer.pressure,
+        role: peer.role,
+        freshKind: peer.freshKind || '',
+        detectedTs: peer.lastDetectedTs || 0
+      });
+
+      const budget = computeGlobalBudget();
+      return Promise.resolve({ ok: true, budget });
+    }
+
+    if (msg?.type === 'tgReplyDetected') {
+      return handleReplyDetected(msg, tabId);
+    }
+
+    if (msg?.type === 'tgNotify') {
+      notifyState.requested += 1;
+      const title = String(msg?.title || 'ChatGPT');
+      const message = String(msg?.message || 'Reply ready in another tab');
+      const eventId = String(msg?.eventId || `manual_${Date.now()}`);
+
+      return sendUserNotification(title, message, normalizeNotifyMeta({
+        eventId,
+        via: 'notify',
+        source: 'manual_notify'
+      })).then((res) => {
+        if (!res.ok) {
+          enqueueNotify({
+            eventId,
+            title,
+            message,
+            source: 'manual_notify',
+            ts: Date.now(),
+            retries: 0,
+            lastErr: res.reason || 'send_failed'
+          });
+        }
+        logNotify({ via: 'notify', eventId, ok: !!res.ok, reason: res.reason || '', silent: true });
+        return { ok: !!res.ok, via: 'notify', reason: res.reason || '', stats: notifyState };
+      });
+    }
+
+    if (msg?.type === 'tgNotifyRetry') {
+      notifyState.retried += 1;
+      const title = String(msg?.title || 'ChatGPT');
+      const message = String(msg?.message || 'Reply ready in another tab');
+      const eventId = String(msg?.eventId || `retry_${Date.now()}`);
+
+      return sendUserNotification(title, message, normalizeNotifyMeta({
+        eventId,
+        via: 'retry',
+        source: 'manual_retry'
+      })).then((res) => {
+        if (!res.ok) {
+          enqueueNotify({
+            eventId,
+            title,
+            message,
+            source: 'manual_retry',
+            ts: Date.now(),
+            retries: 1,
+            lastErr: res.reason || 'retry_failed'
+          });
+        }
+        logNotify({ via: 'retry', eventId, ok: !!res.ok, reason: res.reason || '', silent: true });
+        return { ok: !!res.ok, via: 'retry', reason: res.reason || '', stats: notifyState };
+      });
+    }
+  } catch (e) {
+    console.warn('[TrafficGate] bg onMessage error', e);
+    return Promise.resolve({ ok: false, error: String(e?.message || e || 'unknown') });
+  }
+});

GPTTrafficgateUPDATEDv3.1/content/autopilot.js

@@ -0,0 +1,1053 @@
+// content/autopilot.js — autonomous adaptive controller (clean contract version)
+// Scope: controller state + reply detection + tgSignal/tgReplyDetected + UI events only.
+// No duplicate detector blocks, no global telemetry redefinition, no shadow symbol collisions.
+
+(function () {
+  'use strict';
+
+  const api = (typeof browser !== 'undefined') ? browser : chrome;
+
+  // Canonical notification audio policy for this module (popup yes, sound no)
+  const NOTIFY_SOUND_ENABLED = false;
+
+  // -------------------------
+  // Safe runtime messaging
+  // -------------------------
+  function sendMessageSafe(msg) {
+    return new Promise((resolve, reject) => {
+      try {
+        const maybe = api?.runtime?.sendMessage?.(msg);
+        if (maybe && typeof maybe.then === 'function') {
+          maybe.then(resolve).catch(reject);
+          return;
+        }
+        api.runtime.sendMessage(msg, (resp) => {
+          try {
+            const err = chrome?.runtime?.lastError;
+            if (err) reject(err);
+            else resolve(resp);
+          } catch {
+            resolve(resp);
+          }
+        });
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+
+  const clamp = (n, min, max) => Math.max(min, Math.min(max, n));
+  const nowMs = () => Date.now();
+
+  function dispatchEventSafe(name, detail) {
+    try { window.dispatchEvent(new CustomEvent(name, { detail })); } catch {}
+  }
+
+  // -------------------------
+  // Shared core helpers (consume-only; no re-register)
+  // -------------------------
+  const tgCore = window.__tgCore || null;
+  const stableJsonDumps =
+    (tgCore && typeof tgCore.getCanonical === 'function' && tgCore.getCanonical('stable_json_dumps')) ||
+    ((value) => {
+      const seen = new WeakSet();
+      const walk = (v) => {
+        if (v === null || typeof v !== 'object') return v;
+        if (seen.has(v)) return '[Circular]';
+        seen.add(v);
+        if (Array.isArray(v)) return v.map(walk);
+        const out = {};
+        for (const k of Object.keys(v).sort()) out[k] = walk(v[k]);
+        return out;
+      };
+      return JSON.stringify(walk(value));
+    });
+
+  // -------------------------
+  // Controller state
+  // -------------------------
+  const TAB_ID = `${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+  const COORD_CH = (window.BroadcastChannel ? new BroadcastChannel('tg_multi_tab_coord_v1') : null);
+
+  const cfg = {
+    role: 'follower',
+    leader: false,
+
+    profile: 'balanced',
+    pressure: 0,
+
+    // intent-driven locality
+    topPx: 160,
+    minTopPx: 80,
+
+    // adaptive baselines
+    baselinePressure: 28,
+    baselineLongtasks: 1,
+    baselineTurns: 55,
+    baselineLagMs: 40,
+    baselineSamples: 0,
+
+    // persistence cadence
+    lastPersistTs: 0,
+    lastProfileSwitchTs: 0,
+
+    // user activity
+    lastInputTs: Date.now(),
+
+    // hysteresis cooldown
+    coolDownUntil: 0
+  };
+
+  const stats = {
+    // low-level hooks emit to window.__tgTelemetry (defined elsewhere)
+    cancels: 0,
+    disconnects: 0,
+    longtasks: 0,
+    lastTurnCount: 0,
+    streamActive: false,
+    eventLoopLagMs: 0,
+    eventLoopLagHits: 0
+  };
+
+  const detector = {
+    lastBusy: false,
+    lastAssistantCount: 0,
+    lastDetectorEmitTs: 0,
+    detectorSeq: 0,
+    detectorMisses: 0,
+    lastDetectedTs: 0,
+    lastStreamStartTs: 0,
+    lastStreamEndTs: 0,
+
+    // selector hit telemetry
+    busyHits: {
+      explicit: 0,
+      buttonText: 0,
+      sendDisabled: 0,
+      fallback: 0
+    },
+
+    // stabilization fallback state
+    lastAssistantHash: '',
+    lastAssistantTextLen: 0,
+    lastAssistantChangeTs: 0,
+    lastStableCandidateTs: 0,
+    lastStableEmitTs: 0,
+    stabilizerArmed: false,
+
+    // forced flush guard
+    flushInFlight: false
+  };
+
+  const fresh = {
+    seq: 0,
+    lastSignalTs: 0,
+    lastDetectedTs: 0,
+    lastStreamEndTs: 0,
+    lastKind: 'boot'
+  };
+
+  let globalBudget = { totalStreamers: 0, visibleStreamers: 0, followerHold: false };
+  const peers = new Map(); // from BroadcastChannel
+
+  let replySeq = 0;
+  let pendingDetectedReplyPulse = false;
+  let lastReplySignalAtMs = 0;
+  let lastHeartbeatAtMs = 0;
+
+  const PROFILES = {
+    flow:     { topPx: 120 },
+    balanced: { topPx: 160 },
+    hidden:   { topPx: 100 },
+    recovery: { topPx: 90 }
+  };
+
+  const HYST = {
+    enterRecovery: 70,
+    exitRecovery: 42,
+    enterFlow: 55,
+    exitFlow: 62,
+    minSwitchGapMs: 6000,
+    recoveryCooldownMs: 120000
+  };
+
+  // stabilization fallback tuning
+  const STABILIZER = {
+    minChars: 24,
+    stableForMs: 900,
+    emitCooldownMs: 5500
+  };
+
+  // -------------------------
+  // Freshness / UI event emitters
+  // -------------------------
+  function emitFreshness(kind, extra) {
+    const k = String(kind || 'tick');
+    fresh.lastKind = k;
+
+    const payload = Object.assign({
+      kind: k,
+      ts: nowMs(),
+      tabId: TAB_ID,
+      visible: document.visibilityState === 'visible',
+      streamActive: !!stats.streamActive,
+      profile: cfg.profile,
+      pressure: Number(cfg.pressure || 0),
+      role: cfg.role,
+      seq: fresh.seq
+    }, extra || {});
+
+    dispatchEventSafe('tg:signal-freshness', payload);
+  }
+
+  function emitPerfProfile(reason) {
+    const localBudget = computeLocalBudget();
+
+    const bgTotal = Number(globalBudget?.totalStreamers || 0);
+    const bgVisible = Number(globalBudget?.visibleStreamers || 0);
+
+    const totalStreamers = bgTotal > 0 ? bgTotal : Number(localBudget.totalStreamers || 0);
+    const visibleStreamers = bgVisible > 0 ? bgVisible : Number(localBudget.visibleStreamers || 0);
+
+    const followerThrottle =
+      (typeof globalBudget?.followerHold === 'boolean')
+        ? !!(globalBudget.followerHold && cfg.role !== 'leader')
+        : !!(cfg.role !== 'leader' && (visibleStreamers > 1 || totalStreamers > 2));
+
+    const payload = {
+      profile: cfg.profile,
+      pressure: cfg.pressure,
+      role: cfg.role,
+      streamActive: !!stats.streamActive,
+      visible: document.visibilityState === 'visible',
+      followerThrottle,
+      totalStreamers,
+      visibleStreamers,
+      reason: String(reason || 'tick'),
+      ts: nowMs()
+    };
+    try { window.__tgPerfState = payload; } catch {}
+    dispatchEventSafe('tg:perf-profile', payload);
+  }
+
+  function emitReplyReadyLocal(detail) {
+    const d = Object.assign({}, detail || {});
+    if (!NOTIFY_SOUND_ENABLED) {
+      d.muteSound = true;
+      d.sound = false;
+    }
+    dispatchEventSafe('tg:reply-ready', d);
+    emitFreshness('reply_detected', {
+      eventId: d?.eventId || '',
+      reason: d?.source || 'unknown',
+      replySeq: d?.replySeq || 0
+    });
+  }
+
+  // -------------------------
+  // Telemetry ingestion (consume-only)
+  // -------------------------
+  function ingestTelemetryEvent(event, data) {
+    try {
+      if (event === 'historyCancel') stats.cancels += 1;
+      else if (event === 'disconnect') stats.disconnects += 1;
+      else if (event === 'turnCount' && typeof data?.count === 'number') stats.lastTurnCount = data.count;
+      else if (event === 'streamActive') {
+        const prev = !!stats.streamActive;
+        const next = !!data?.active;
+        stats.streamActive = next;
+
+        if (next && !prev) {
+          detector.lastStreamStartTs = nowMs();
+          emitFreshness('stream_transition', { transition: 'start', streamStartTs: detector.lastStreamStartTs });
+        } else if (prev && !next) {
+          detector.lastStreamEndTs = nowMs();
+          fresh.lastStreamEndTs = detector.lastStreamEndTs;
+          emitFreshness('stream_transition', { transition: 'end', streamEndTs: detector.lastStreamEndTs });
+          emitReplyFinished('stream-transition').catch(() => {});
+        }
+      }
+    } catch {}
+  }
+
+  // Consume events from net-guard/dom-softcap/keepalive via core bus if available
+  if (tgCore && typeof tgCore.on === 'function') {
+    try {
+      tgCore.on('tg:telemetry', (d) => ingestTelemetryEvent(d?.event, d?.data));
+    } catch {}
+  }
+
+  // Compatibility path: if an existing sink exists, wrap it instead of redefining global symbol.
+  try {
+    const existingSink = window.__tgTelemetry;
+    if (typeof existingSink === 'function' && !window.__tgTelemetryWrappedByAutopilot) {
+      window.__tgTelemetryWrappedByAutopilot = true;
+      window.__tgTelemetry = function wrappedTelemetry(event, data) {
+        try { ingestTelemetryEvent(event, data); } catch {}
+        try { return existingSink.apply(this, arguments); } catch { return undefined; }
+      };
+    }
+  } catch {}
+
+  // -------------------------
+  // Reply detection (single detector pipeline)
+  // -------------------------
+  function getAssistantTurnCount() {
+    try {
+      const a = document.querySelectorAll('[data-message-author-role="assistant"]').length;
+      const b = document.querySelectorAll('[data-testid^="conversation-turn-"]').length;
+      const c = document.querySelectorAll('article[data-testid*="conversation-turn"]').length;
+      return Math.max(a, b, c, 0);
+    } catch {
+      return 0;
+    }
+  }
+
+  function getLastAssistantText() {
+    try {
+      const nodes = document.querySelectorAll('[data-message-author-role="assistant"]');
+      if (!nodes || !nodes.length) return '';
+      const last = nodes[nodes.length - 1];
+      const txt = (last?.innerText || last?.textContent || '').replace(/\s+/g, ' ').trim();
+      return txt;
+    } catch {
+      return '';
+    }
+  }
+
+  function quickHash(s) {
+    // fast deterministic 32-bit hash string form
+    let h = 2166136261 >>> 0;
+    for (let i = 0; i < s.length; i++) {
+      h ^= s.charCodeAt(i);
+      h = Math.imul(h, 16777619);
+    }
+    return (h >>> 0).toString(16);
+  }
+
+  function detectDomBusy() {
+    try {
+      // 1) Explicit selectors (legacy + current variants)
+      const explicitSelectors = [
+        '[data-testid*="stop"]',
+        '[data-testid*="regenerate"]',
+        'button[aria-label*="Stop"]',
+        'button[aria-label*="Stop generating"]',
+        'button[aria-label*="Stop streaming"]',
+        '[data-is-streaming="true"]',
+        '[aria-busy="true"]',
+        '.result-streaming',
+        '[class*="typing"]'
+      ];
+      const explicit = document.querySelectorAll(explicitSelectors.join(',')).length > 0;
+      if (explicit) {
+        detector.busyHits.explicit += 1;
+        return true;
+      }
+
+      // 2) Robust button text fallback
+      const btns = Array.from(document.querySelectorAll('button'));
+      for (const b of btns) {
+        const txt = (b.textContent || '').trim().toLowerCase();
+        const aria = (b.getAttribute('aria-label') || '').trim().toLowerCase();
+        const title = (b.getAttribute('title') || '').trim().toLowerCase();
+        const blob = `${txt} ${aria} ${title}`;
+
+        if (
+          blob.includes('stop generating') ||
+          blob.includes('stop streaming') ||
+          blob === 'stop' ||
+          blob.includes('thinking') ||
+          blob.includes('cancel')
+        ) {
+          detector.busyHits.buttonText += 1;
+          return true;
+        }
+      }
+
+      // 3) Composer/send-state heuristic
+      const sendBtn = document.querySelector('button[data-testid*="send"], form button[type="submit"]');
+      if (sendBtn && sendBtn.disabled) {
+        detector.busyHits.sendDisabled += 1;
+        return true;
+      }
+
+      return false;
+    } catch {
+      detector.busyHits.fallback += 1;
+      return !!stats.streamActive;
+    }
+  }
+
+  async function emitReplyFinished(source) {
+    const t = nowMs();
+    const minGapMs = 3500;
+
+    // hard dedupe
+    if ((t - lastReplySignalAtMs) < minGapMs) return;
+    if ((t - detector.lastDetectorEmitTs) < minGapMs) return;
+
+    detector.lastDetectorEmitTs = t;
+    detector.lastDetectedTs = t;
+    fresh.lastDetectedTs = t;
+    lastReplySignalAtMs = t;
+    pendingDetectedReplyPulse = true;
+
+    replySeq += 1;
+    detector.detectorSeq += 1;
+
+    const eventId = `reply_${TAB_ID}_${t}_${detector.detectorSeq}`;
+    const localDetail = {
+      tabId: TAB_ID,
+      replySeq,
+      source: source || 'unknown',
+      title: document.title || 'ChatGPT replied',
+      ts: t,
+      eventId
+    };
+
+    // UI/local path
+    emitReplyReadyLocal(localDetail);
+
+    // Background broker path (authoritative notify flow)
+    try {
+      const msg = {
+        type: 'tgReplyDetected',
+        eventId,
+        source: `autopilot:${source || 'unknown'}`,
+        detectedTs: t,
+        streamEndTs: detector.lastStreamEndTs || 0,
+        title: 'ChatGPT',
+        message: 'Reply finished in another tab',
+        roleHint: cfg.role || 'follower'
+      };
+      if (!NOTIFY_SOUND_ENABLED) {
+        msg.muteSound = true;
+        msg.sound = false;
+        msg.silent = true;
+      }
+      await sendMessageSafe(msg);
+    } catch {}
+
+    // Peer hint path
+    if (COORD_CH) {
+      try {
+        const peerMsg = {
+          type: 'reply-ready',
+          tabId: TAB_ID,
+          ts: t,
+          replySeq,
+          source: source || 'unknown',
+          eventId
+        };
+        if (!NOTIFY_SOUND_ENABLED) {
+          peerMsg.muteSound = true;
+          peerMsg.sound = false;
+          peerMsg.silent = true;
+        }
+        COORD_CH.postMessage(peerMsg);
+      } catch {}
+    }
+
+    // Flush detector freshness immediately so bg health/UI are not stale.
+    if (!detector.flushInFlight) {
+      detector.flushInFlight = true;
+      try { await sendSignal({ force: true }); } catch {}
+      detector.flushInFlight = false;
+    }
+  }
+
+  function evaluateStabilizedReply(busy, source) {
+    try {
+      const t = nowMs();
+      const txt = getLastAssistantText();
+      if (!txt || txt.length < STABILIZER.minChars) {
+        detector.stabilizerArmed = false;
+        return;
+      }
+
+      const h = quickHash(txt);
+      const changed = (h !== detector.lastAssistantHash) || (txt.length !== detector.lastAssistantTextLen);
+
+      if (changed) {
+        detector.lastAssistantHash = h;
+        detector.lastAssistantTextLen = txt.length;
+        detector.lastAssistantChangeTs = t;
+        detector.lastStableCandidateTs = t;
+        detector.stabilizerArmed = true;
+        return;
+      }
+
+      if (!detector.stabilizerArmed) return;
+      if (busy) return;
+
+      const stableFor = t - (detector.lastAssistantChangeTs || t);
+      const emitAgo = t - (detector.lastStableEmitTs || 0);
+
+      if (stableFor >= STABILIZER.stableForMs && emitAgo >= STABILIZER.emitCooldownMs) {
+        detector.lastStableEmitTs = t;
+        detector.stabilizerArmed = false;
+
+        emitFreshness('stabilized_candidate', {
+          source: source || 'stabilizer',
+          stableForMs: stableFor,
+          textLen: txt.length
+        });
+
+        emitReplyFinished(`${source || 'stabilizer'}-stable`).catch(() => {});
+      }
+    } catch {}
+  }
+
+  async function handleBusyEdge(nextBusy, source) {
+    const prevBusy = !!detector.lastBusy;
+    const nowBusy = !!nextBusy;
+    if (prevBusy === nowBusy) return;
+
+    detector.lastBusy = nowBusy;
+    stats.streamActive = nowBusy;
+
+    if (nowBusy) {
+      detector.lastStreamStartTs = nowMs();
+      emitFreshness('stream_transition', {
+        transition: 'start',
+        source: source || 'edge',
+        streamStartTs: detector.lastStreamStartTs
+      });
+      await sendSignal({ force: true });
+      return;
+    }
+
+    detector.lastStreamEndTs = nowMs();
+    fresh.lastStreamEndTs = detector.lastStreamEndTs;
+
+    emitFreshness('stream_transition', {
+      transition: 'end',
+      source: source || 'edge',
+      streamEndTs: detector.lastStreamEndTs
+    });
+
+    // Ensure detected state is stamped before final forced signal.
+    await emitReplyFinished(`${source || 'edge'}-end`);
+    await sendSignal({ force: true });
+  }
+
+  let replyObserver = null;
+  function startReplyObserver() {
+    if (replyObserver) return;
+    const root = document.querySelector('main') || document.body;
+    if (!root) return;
+
+    detector.lastBusy = detectDomBusy();
+    detector.lastAssistantCount = getAssistantTurnCount();
+    stats.streamActive = !!detector.lastBusy;
+
+    replyObserver = new MutationObserver(() => {
+      const busy = detectDomBusy();
+      const turns = getAssistantTurnCount();
+
+      // Busy edge handling (start/end)
+      handleBusyEdge(busy, 'dom-observer').catch(() => {});
+
+      // New assistant turn while idle
+      if (!busy && turns > detector.lastAssistantCount) {
+        emitReplyFinished('dom-turn-growth').catch(() => {});
+      }
+
+      // Content stabilization fallback
+      evaluateStabilizedReply(busy, 'dom-observer');
+
+      detector.lastBusy = busy;
+      stats.streamActive = !!busy;
+      detector.lastAssistantCount = turns;
+    });
+
+    replyObserver.observe(root, { childList: true, subtree: true, attributes: true });
+  }
+
+  // -------------------------
+  // Cross-tab coordination / budget
+  // -------------------------
+  function prunePeers() {
+    const t = nowMs();
+    for (const [k, v] of peers.entries()) {
+      if (!v || (t - (v.ts || 0)) > 15000) peers.delete(k);
+    }
+  }
+
+  function computeLocalBudget() {
+    prunePeers();
+
+    const selfVisible = (document.visibilityState === 'visible');
+    let selfStreaming = !!stats.streamActive;
+    try {
+      if (!selfStreaming) selfStreaming = !!detectDomBusy();
+    } catch {}
+
+    let total = selfStreaming ? 1 : 0;
+    let visible = (selfStreaming && selfVisible) ? 1 : 0;
+
+    for (const v of peers.values()) {
+      if (!v?.streaming) continue;
+      total += 1;
+      if (v.visible) visible += 1;
+    }
+
+    return {
+      totalStreamers: total,
+      visibleStreamers: visible
+    };
+  }
+
+  function computeExternalBusyScore() {
+    prunePeers();
+    let score = 0;
+    for (const v of peers.values()) {
+      if (v?.streaming) score += v.visible ? 18 : 9;
+    }
+    return clamp(score, 0, 45);
+  }
+
+  if (COORD_CH) {
+    try {
+      COORD_CH.onmessage = (ev) => {
+        const msg = ev?.data || null;
+        if (!msg || msg.tabId === TAB_ID) return;
+
+        if (msg.type === 'coord') {
+          peers.set(msg.tabId, {
+            ts: Number(msg.ts || nowMs()),
+            streaming: !!msg.streaming,
+            visible: !!msg.visible,
+            pressure: Number(msg.pressure || 0),
+            role: String(msg.role || 'follower')
+          });
+        } else if (msg.type === 'reply-ready') {
+          // UI fallback only; no re-detect logic
+          dispatchEventSafe('tg:reply-ready', msg);
+          emitFreshness('reply_detected', {
+            reason: `coord:${msg.source || 'peer'}`,
+            eventId: msg.eventId || ''
+          });
+        }
+      };
+    } catch {}
+  }
+
+  try {
+    api.runtime.onMessage.addListener((msg) => {
+      if (!msg) return;
+      if (msg.type === 'tgGlobalBudget') {
+        globalBudget = msg.budget || globalBudget;
+      } else if (msg.type === 'tgRole') {
+        cfg.role = String(msg.role || 'follower');
+        cfg.leader = (cfg.role === 'leader');
+      }
+    });
+  } catch {}
+
+  // -------------------------
+  // Pressure / profile logic
+  // -------------------------
+  function ewma(prev, next, alpha) {
+    return (prev * (1 - alpha)) + (next * alpha);
+  }
+
+  function computePressure() {
+    const visible = (document.visibilityState === 'visible');
+    const idleMs = nowMs() - cfg.lastInputTs;
+
+    const ltOver = Math.max(0, stats.longtasks - cfg.baselineLongtasks);
+    const turnOver = Math.max(0, stats.lastTurnCount - cfg.baselineTurns);
+    const lagOver = Math.max(0, stats.eventLoopLagMs - cfg.baselineLagMs);
+
+    let p = cfg.baselinePressure * 0.35;
+    p += clamp(ltOver * 9, 0, 45);
+    p += clamp(stats.disconnects * 8, 0, 24);
+    p += clamp(turnOver * 0.18, 0, 18);
+    p += clamp(lagOver * 0.16, 0, 20);
+    if (stats.streamActive) p += 14;
+    if (visible && idleMs < 20000) p += 8;
+    if (!visible) p -= 12;
+    if (stats.eventLoopLagHits >= 3) p += 10;
+    p += computeExternalBusyScore();
+
+    return clamp(Math.round(p), 0, 100);
+  }
+
+  function chooseProfile() {
+    const visible = (document.visibilityState === 'visible');
+    const idleMs = nowMs() - cfg.lastInputTs;
+    const inCooldown = (nowMs() < cfg.coolDownUntil);
+
+    if (!visible) return 'hidden';
+
+    if (cfg.profile === 'recovery') {
+      if (inCooldown || cfg.pressure > HYST.exitRecovery) return 'recovery';
+    }
+
+    if (cfg.pressure >= HYST.enterRecovery || stats.eventLoopLagHits >= 4) {
+      cfg.coolDownUntil = nowMs() + HYST.recoveryCooldownMs;
+      return 'recovery';
+    }
+
+    if (stats.streamActive || idleMs < 12000) {
+      if (cfg.pressure <= HYST.exitFlow) return 'flow';
+      return 'recovery';
+    }
+
+    if (cfg.profile === 'flow' && cfg.pressure <= HYST.enterFlow) return 'flow';
+    return 'balanced';
+  }
+
+  function applyProfile(next, reason) {
+    const t = nowMs();
+    if (next !== cfg.profile && (t - cfg.lastProfileSwitchTs) < HYST.minSwitchGapMs) return;
+
+    cfg.profile = next;
+    cfg.lastProfileSwitchTs = t;
+    cfg.topPx = clamp(Number(PROFILES[next]?.topPx || 160), cfg.minTopPx, 500);
+
+    emitPerfProfile(reason || 'profile');
+  }
+
+  function learnBaselines() {
+    if (document.visibilityState !== 'visible') return;
+    if (cfg.profile === 'recovery') return;
+
+    cfg.baselineSamples += 1;
+    cfg.baselineLongtasks = ewma(cfg.baselineLongtasks, stats.longtasks, 0.08);
+    cfg.baselineTurns = ewma(cfg.baselineTurns, stats.lastTurnCount || cfg.baselineTurns, 0.03);
+    cfg.baselineLagMs = ewma(cfg.baselineLagMs, stats.eventLoopLagMs || cfg.baselineLagMs, 0.06);
+    cfg.baselinePressure = ewma(cfg.baselinePressure, cfg.pressure, 0.04);
+  }
+
+  async function persistBaselinesMaybe() {
+    const t = nowMs();
+    if ((t - cfg.lastPersistTs) < 30000) return;
+    cfg.lastPersistTs = t;
+
+    try {
+      await api.storage.local.set({
+        tg_baseline_v1: {
+          pressure: cfg.baselinePressure,
+          longtasks: cfg.baselineLongtasks,
+          turns: cfg.baselineTurns,
+          lagMs: cfg.baselineLagMs,
+          samples: cfg.baselineSamples,
+          ts: t
+        }
+      });
+    } catch {}
+  }
+
+  async function loadBaselines() {
+    try {
+      const res = await api.storage.local.get(['tg_baseline_v1']);
+      const b = res?.tg_baseline_v1 || null;
+      if (b && typeof b === 'object') {
+        cfg.baselinePressure = clamp(Number(b.pressure) || cfg.baselinePressure, 8, 90);
+        cfg.baselineLongtasks = clamp(Number(b.longtasks) || cfg.baselineLongtasks, 0, 20);
+        cfg.baselineTurns = clamp(Number(b.turns) || cfg.baselineTurns, 10, 300);
+        cfg.baselineLagMs = clamp(Number(b.lagMs) || cfg.baselineLagMs, 5, 250);
+        cfg.baselineSamples = clamp(Number(b.samples) || 0, 0, 1000000);
+      }
+    } catch {}
+  }
+
+  // -------------------------
+  // Intent gating
+  // -------------------------
+  let lastScrollTop = 0;
+  let lastUpAt = 0;
+
+  async function updateIntent() {
+    if (document.visibilityState !== 'visible') return;
+
+    const sc = document.scrollingElement || document.documentElement;
+    const st = sc.scrollTop || 0;
+    const t = nowMs();
+
+    if (st < lastScrollTop - 2) lastUpAt = t;
+    lastScrollTop = st;
+
+    const nearTop = (st < cfg.topPx);
+    const recentUp = (t - lastUpAt) < 1500;
+    const allow = !!(nearTop || recentUp);
+
+    try { window.__chatTrafficGate?.setIntent?.(allow); } catch {}
+    try { await sendMessageSafe({ type: 'historyIntent', value: allow }); } catch {}
+  }
+
+  // -------------------------
+  // Heartbeat + tgSignal
+  // -------------------------
+  async function sendSignal(opts) {
+    const options = opts || {};
+    const force = !!options.force;
+
+    const t = nowMs();
+    if (!force && (t - lastHeartbeatAtMs) < 2500) return;
+    lastHeartbeatAtMs = t;
+
+    fresh.seq += 1;
+    fresh.lastSignalTs = t;
+
+    const pulse = pendingDetectedReplyPulse;
+    pendingDetectedReplyPulse = false;
+
+    // Robust streaming truth: telemetry first, DOM fallback
+    let effectiveStreaming = !!stats.streamActive;
+    try {
+      if (!effectiveStreaming) effectiveStreaming = !!detectDomBusy();
+    } catch {}
+    stats.streamActive = !!effectiveStreaming;
+
+    emitFreshness(force ? 'heartbeat_forced' : 'heartbeat', {
+      detectedReplyPulse: !!pulse,
+      detectorMisses: detector.detectorMisses,
+      lastDetectedTs: detector.lastDetectedTs || 0,
+      lastStreamEndTs: detector.lastStreamEndTs || 0,
+      busyHitExplicit: detector.busyHits.explicit || 0,
+      busyHitButtonText: detector.busyHits.buttonText || 0,
+      busyHitSendDisabled: detector.busyHits.sendDisabled || 0,
+      busyHitFallback: detector.busyHits.fallback || 0,
+      stabilizerArmed: !!detector.stabilizerArmed,
+      lastStableCandidateTs: detector.lastStableCandidateTs || 0,
+      lastStableEmitTs: detector.lastStableEmitTs || 0
+    });
+
+    try {
+      const resp = await sendMessageSafe({
+        type: 'tgSignal',
+        visible: document.visibilityState === 'visible',
+        streaming: !!effectiveStreaming,
+        pressure: Number(cfg.pressure || 0),
+        role: String(cfg.role || 'follower'),
+
+        // freshness contract fields
+        seq: fresh.seq,
+        lastSignalTs: t,
+        lastDetectedTs: detector.lastDetectedTs || 0,
+        lastStreamEndTs: detector.lastStreamEndTs || 0,
+        detectorMisses: detector.detectorMisses,
+        freshKind: fresh.lastKind,
+
+        // compatibility pulse fields for background freshness paths
+        detectedReply: !!pulse,
+        detectedReplyPulse: !!pulse,
+
+        // detector telemetry
+        busyHitExplicit: detector.busyHits.explicit || 0,
+        busyHitButtonText: detector.busyHits.buttonText || 0,
+        busyHitSendDisabled: detector.busyHits.sendDisabled || 0,
+        busyHitFallback: detector.busyHits.fallback || 0,
+        stabilizerArmed: !!detector.stabilizerArmed,
+        lastStableCandidateTs: detector.lastStableCandidateTs || 0,
+        lastStableEmitTs: detector.lastStableEmitTs || 0,
+        lastAssistantHash: detector.lastAssistantHash || '',
+        lastAssistantTextLen: detector.lastAssistantTextLen || 0
+      });
+
+      if (resp?.budget) globalBudget = resp.budget;
+    } catch {}
+  }
+
+  // -------------------------
+  // Event loop lag / long task observation
+  // -------------------------
+  let perfObs = null;
+  let lagTimer = null;
+
+  function startPerfObservers() {
+    if (!perfObs) {
+      try {
+        perfObs = new PerformanceObserver((list) => {
+          for (const e of list.getEntries()) {
+            if (e.duration >= 200) stats.longtasks += 1;
+          }
+        });
+        perfObs.observe({ entryTypes: ['longtask'] });
+      } catch { perfObs = null; }
+    }
+
+    if (!lagTimer) {
+      let last = performance.now();
+      lagTimer = setInterval(() => {
+        const n = performance.now();
+        const drift = Math.max(0, n - last - 1000);
+        last = n;
+
+        stats.eventLoopLagMs = Math.round(ewma(stats.eventLoopLagMs || 0, drift, 0.25));
+        if (drift > 220) stats.eventLoopLagHits += 1;
+        else stats.eventLoopLagHits = Math.max(0, stats.eventLoopLagHits - 1);
+      }, 1000);
+    }
+  }
+
+  function stopPerfObservers() {
+    try { perfObs?.disconnect?.(); } catch {}
+    perfObs = null;
+    if (lagTimer) clearInterval(lagTimer);
+    lagTimer = null;
+  }
+
+  // -------------------------
+  // Main control loop
+  // -------------------------
+  function decayCounters() {
+    stats.longtasks = Math.max(0, stats.longtasks - 1);
+    stats.cancels = Math.max(0, stats.cancels - 2);
+    stats.disconnects = Math.max(0, stats.disconnects - 1);
+    stats.eventLoopLagHits = Math.max(0, stats.eventLoopLagHits - 1);
+  }
+
+  async function controllerTick() {
+    cfg.pressure = computePressure();
+
+    const nextProfile = chooseProfile();
+    if (nextProfile !== cfg.profile) applyProfile(nextProfile, 'profile-switch');
+    else emitPerfProfile('tick');
+
+    await updateIntent();
+    await sendSignal();
+
+    learnBaselines();
+    decayCounters();
+    await persistBaselinesMaybe();
+
+    // publish lightweight coord (use same robust streaming truth)
+    if (COORD_CH) {
+      try {
+        let effectiveStreaming = !!stats.streamActive;
+        try {
+          if (!effectiveStreaming) effectiveStreaming = !!detectDomBusy();
+        } catch {}
+        stats.streamActive = !!effectiveStreaming;
+
+        COORD_CH.postMessage({
+          type: 'coord',
+          tabId: TAB_ID,
+          ts: nowMs(),
+          streaming: !!effectiveStreaming,
+          visible: (document.visibilityState === 'visible'),
+          pressure: cfg.pressure,
+          profile: cfg.profile,
+          role: cfg.role
+        });
+      } catch {}
+    }
+  }
+
+  // -------------------------
+  // Lifecycle
+  // -------------------------
+  let ctrlTimer = null;
+  let intentTimer = null;
+  let pollTimer = null;
+
+  function startLoops() {
+    if (!ctrlTimer) ctrlTimer = setInterval(() => { controllerTick().catch(() => {}); }, 5000);
+    if (!intentTimer) intentTimer = setInterval(() => { updateIntent().catch(() => {}); }, 2000);
+
+    // Secondary reply detector safety poll (single block only)
+    if (!pollTimer) {
+      pollTimer = setInterval(() => {
+        try {
+          const busy = detectDomBusy();
+          const turns = getAssistantTurnCount();
+
+          // Busy edge handling (start/end)
+          handleBusyEdge(busy, 'poll').catch(() => {});
+
+          if (!busy && turns > detector.lastAssistantCount) {
+            emitReplyFinished('poll-turn-growth').catch(() => {});
+          }
+
+          // Content stabilization fallback
+          evaluateStabilizedReply(busy, 'poll');
+
+          const missCondition =
+            detector.lastStreamEndTs > 0 &&
+            detector.lastDetectedTs < detector.lastStreamEndTs &&
+            (nowMs() - detector.lastStreamEndTs > 8000);
+
+          if (missCondition) {
+            detector.detectorMisses += 1;
+            emitFreshness('detector_miss', { detectorMisses: detector.detectorMisses });
+            emitReplyFinished('miss-recovery').catch(() => {});
+          }
+
+          detector.lastBusy = busy;
+          stats.streamActive = !!busy;
+          detector.lastAssistantCount = turns;
+        } catch {}
+      }, 1200);
+    }
+
+    startPerfObservers();
+  }
+
+  function stopLoops() {
+    if (ctrlTimer) clearInterval(ctrlTimer);
+    if (intentTimer) clearInterval(intentTimer);
+    if (pollTimer) clearInterval(pollTimer);
+    ctrlTimer = null;
+    intentTimer = null;
+    pollTimer = null;
+
+    stopPerfObservers();
+
+    // hidden mode still sends explicit no-intent once
+    try { window.__chatTrafficGate?.setIntent?.(false); } catch {}
+    sendMessageSafe({ type: 'historyIntent', value: false }).catch(() => {});
+
+    applyProfile('hidden', 'visibility-hidden');
+  }
+
+  function markUserActive() { cfg.lastInputTs = nowMs(); }
+  window.addEventListener('pointerdown', markUserActive, { passive: true, capture: true });
+  window.addEventListener('keydown', markUserActive, { passive: true, capture: true });
+
+  document.addEventListener('visibilitychange', () => {
+    if (document.visibilityState === 'visible') startLoops();
+    else stopLoops();
+  }, { passive: true });
+
+  // role discovery
+  (async () => {
+    try {
+      const resp = await sendMessageSafe({ type: 'requestStatus' });
+      if (resp?.role) {
+        cfg.role = String(resp.role);
+        cfg.leader = (cfg.role === 'leader');
+      }
+    } catch {}
+  })();
+
+  // boot
+  startReplyObserver();
+  loadBaselines().finally(() => {
+    if (document.visibilityState === 'visible') startLoops();
+    else stopLoops();
+
+    // prime bg freshness state immediately on boot
+    sendSignal({ force: true }).catch(() => {});
+
+    emitFreshness('boot', {
+      baselineLoaded: true,
+      visibility: document.visibilityState,
+      tabId: TAB_ID
+    });
+
+    // initial snapshot to UI panel
+    try {
+      const snap = stableJsonDumps({
+        profile: cfg.profile,
+        pressure: cfg.pressure,
+        role: cfg.role
+      });
+      emitFreshness('boot_snapshot', { snapshot: snap });
+    } catch {}
+  });
+})();

GPTTrafficgateUPDATEDv3.1/content/core-utils.js

@@ -0,0 +1,414 @@
+(() => {
+  'use strict';
+
+  const root = window;
+  const GUARD_KEY = '__tgCore_bootstrapped_v3';
+  const CORE_VERSION = '3.1.0';
+
+  const makeToken = () =>
+    `tg_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+
+  // Reinjection-safe: if already initialized, ensure compatibility shim exists and exit.
+  if (root[GUARD_KEY] && root.__tgCore) {
+    if (!root.__tgBus) {
+      root.__tgBus = Object.freeze({
+        emit: (name, detail) => { try { root.__tgCore.emitDom(name, detail); } catch {} },
+        on: (name, fn, opt) => {
+          try { return root.__tgCore.onDom(name, fn, opt || { passive: true }); } catch { return () => {}; }
+        }
+      });
+    }
+
+    // Signal reuse path for downstream modules that wait on core availability.
+    try {
+      root.__tgCore.emitDom('tg:core-reused', {
+        ts: Date.now(),
+        version: root.__tgCore?.version || CORE_VERSION,
+        reused: true
+      });
+    } catch {}
+    return;
+  }
+
+  const deepFreeze = (obj) => {
+    if (!obj || typeof obj !== 'object') return obj;
+    Object.freeze(obj);
+    for (const k of Object.getOwnPropertyNames(obj)) {
+      const v = obj[k];
+      if (v && typeof v === 'object' && !Object.isFrozen(v)) deepFreeze(v);
+    }
+    return obj;
+  };
+
+  if (!root.__tgCore) {
+    const canon = Object.create(null);         // canonical helpers
+    const owners = Object.create(null);        // helper owner map
+    const state = Object.create(null);         // shared state
+    const listeners = new Map();               // internal event bus: event -> Set<fn>
+    const symbolOwners = Object.create(null);  // claimed global symbols
+    const domForwardGuard = '__tgBusOrigin';   // recursion guard key in event detail
+
+    const bootTs = Date.now();
+    const instanceId = `core_${bootTs.toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+
+    let debugEnabled = !!root.__TG_DEBUG;
+
+    const stableJsonDumps = (value) => {
+      const seen = new WeakSet();
+      const walk = (v) => {
+        if (v === null || typeof v !== 'object') {
+          if (typeof v === 'bigint') return `${String(v)}n`;
+          if (typeof v === 'function') return `[Function ${v.name || 'anonymous'}]`;
+          if (typeof v === 'symbol') return String(v);
+          return v;
+        }
+        if (seen.has(v)) return '[Circular]';
+        seen.add(v);
+
+        if (Array.isArray(v)) return v.map(walk);
+
+        const out = {};
+        for (const k of Object.keys(v).sort()) out[k] = walk(v[k]);
+        return out;
+      };
+      return JSON.stringify(walk(value));
+    };
+
+    const loadJson = (raw, fallback = null) => {
+      if (typeof raw !== 'string') return fallback;
+      try { return JSON.parse(raw); } catch { return fallback; }
+    };
+
+    /**
+     * registerCanonical(name, fn, owner, opts)
+     * opts:
+     *  - allowSameOwnerOverride: boolean
+     *  - allowExistingNoop: boolean (silently return existing)
+     */
+    const registerCanonical = (name, fn, owner = 'unknown', opts = null) => {
+      if (typeof name !== 'string' || !name.trim()) {
+        throw new TypeError('Canonical helper name must be a non-empty string');
+      }
+      if (typeof fn !== 'function') {
+        throw new TypeError(`Canonical helper ${name} must be a function`);
+      }
+
+      const key = name.trim();
+      const current = canon[key];
+      const currentOwner = owners[key];
+
+      if (current && current !== fn) {
+        const sameOwner = currentOwner === owner;
+        const allowSameOwnerOverride = !!opts?.allowSameOwnerOverride;
+        const allowExistingNoop = !!opts?.allowExistingNoop;
+
+        if (allowExistingNoop) return current;
+        if (sameOwner && allowSameOwnerOverride) {
+          canon[key] = fn;
+          owners[key] = owner;
+          return fn;
+        }
+
+        throw new Error(
+          `Duplicate canonical helper blocked: ${key} (owned by ${currentOwner}, attempted by ${owner})`
+        );
+      }
+
+      if (!current) {
+        canon[key] = fn;
+        owners[key] = owner;
+      }
+      return canon[key];
+    };
+
+    const blockDuplicateUtility = (name, owner = 'unknown') => {
+      const existingOwner = owners[name] || null;
+      if (existingOwner && existingOwner !== owner) {
+        throw new Error(
+          `Duplicate utility symbol blocked: ${name} (canonical owner: ${existingOwner}, attempted by ${owner})`
+        );
+      }
+      return true;
+    };
+
+    /**
+     * Explicit global-symbol claim system for low-level hooks that need singleton globals.
+     */
+    const claimGlobalSymbol = (name, owner = 'unknown', opts = null) => {
+      if (typeof name !== 'string' || !name.trim()) {
+        throw new TypeError('Global symbol name must be a non-empty string');
+      }
+      const key = name.trim();
+      const existing = symbolOwners[key];
+
+      if (!existing) {
+        symbolOwners[key] = owner;
+        return true;
+      }
+
+      if (existing === owner) return true;
+      if (opts?.allowTakeover === true) {
+        symbolOwners[key] = owner;
+        return true;
+      }
+
+      throw new Error(
+        `Global symbol already claimed: ${key} (owner: ${existing}, attempted by: ${owner})`
+      );
+    };
+
+    const releaseGlobalSymbol = (name, owner = 'unknown') => {
+      const key = String(name || '').trim();
+      if (!key) return false;
+      const existing = symbolOwners[key];
+      if (!existing) return false;
+      if (existing !== owner) return false;
+      delete symbolOwners[key];
+      return true;
+    };
+
+    const createPrivateName = (owner, localName) =>
+      `__tg_${String(owner).replace(/[^a-zA-Z0-9_]+/g, '_')}__${String(localName || '').replace(/[^a-zA-Z0-9_]+/g, '_')}`;
+
+    // Internal event bus
+    const emit = (event, detail = null) => {
+      const evt = String(event || '');
+      if (!evt) return 0;
+      const set = listeners.get(evt);
+      if (!set || set.size === 0) return 0;
+      let n = 0;
+      for (const fn of set) {
+        try { fn(detail); n++; } catch {}
+      }
+      return n;
+    };
+
+    const on = (event, fn, opts = null) => {
+      if (typeof fn !== 'function') throw new TypeError('listener must be a function');
+      const evt = String(event || '');
+      if (!evt) throw new TypeError('event must be a non-empty string');
+
+      let set = listeners.get(evt);
+      if (!set) {
+        set = new Set();
+        listeners.set(evt, set);
+      }
+
+      if (opts?.once) {
+        const onceWrapper = (detail) => {
+          try { fn(detail); } finally { try { off(evt, onceWrapper); } catch {} }
+        };
+        set.add(onceWrapper);
+        return () => off(evt, onceWrapper);
+      }
+
+      set.add(fn);
+      return () => off(evt, fn);
+    };
+
+    const off = (event, fn) => {
+      const evt = String(event || '');
+      if (!evt) return false;
+      const set = listeners.get(evt);
+      if (!set) return false;
+      const had = set.delete(fn);
+      if (set.size === 0) listeners.delete(evt);
+      return had;
+    };
+
+    // DOM bridge
+    const emitDom = (event, detail = null) => {
+      const evt = String(event || '');
+      if (!evt) return false;
+      try {
+        const token =
+          (detail && typeof detail === 'object' && detail.__tgEventToken)
+            ? detail.__tgEventToken
+            : makeToken();
+
+        const payload = (detail && typeof detail === 'object')
+          ? { ...detail, __tgEventToken: token, [domForwardGuard]: true }
+          : { value: detail, __tgEventToken: token, [domForwardGuard]: true };
+
+        window.dispatchEvent(new CustomEvent(evt, { detail: payload }));
+        return true;
+      } catch {
+        return false;
+      }
+    };
+
+    const onDom = (event, fn, opts = null) => {
+      const evt = String(event || '');
+      if (!evt || typeof fn !== 'function') return () => {};
+
+      const once = !!opts?.once;
+      const nativeOpts = {
+        passive: (opts?.passive !== false),
+        capture: !!opts?.capture,
+        once
+      };
+
+      const handler = (e) => {
+        try { fn(e?.detail ?? null, e); } catch {}
+      };
+
+      try {
+        window.addEventListener(evt, handler, nativeOpts);
+        return () => {
+          try { window.removeEventListener(evt, handler, nativeOpts); } catch {}
+        };
+      } catch {
+        return () => {};
+      }
+    };
+
+    // Internal + DOM one-shot emit
+    const emitBoth = (event, detail = null) => {
+      const payload = (detail && typeof detail === 'object')
+        ? { ...detail }
+        : { value: detail };
+
+      if (!payload.__tgEventToken) payload.__tgEventToken = makeToken();
+
+      const n = emit(event, payload);
+      emitDom(event, payload);
+      return n;
+    };
+
+    // Subscribe to internal + DOM; avoids duplicate callback when both fire in sequence
+    const onAny = (event, fn, opts = null) => {
+      if (typeof fn !== 'function') return () => {};
+      let lastToken = null;
+
+      const offInternal = on(event, (detail) => {
+        const tok = detail && typeof detail === 'object' ? detail.__tgEventToken : null;
+        if (tok && tok === lastToken) return;
+        lastToken = tok || null;
+        fn(detail);
+      });
+
+      const offDom = onDom(event, (detail) => {
+        const tok = detail && typeof detail === 'object' ? detail.__tgEventToken : null;
+        if (tok && tok === lastToken) return;
+        lastToken = tok || null;
+        fn(detail);
+      }, opts);
+
+      return () => { try { offInternal(); } catch {} try { offDom(); } catch {} };
+    };
+
+    const setState = (k, v) => { state[k] = v; return v; };
+    const getState = (k, fallback = null) => (Object.prototype.hasOwnProperty.call(state, k) ? state[k] : fallback);
+    const snapshotState = () => Object.assign({}, state);
+    const clearState = (k) => {
+      if (typeof k === 'undefined') {
+        for (const key of Object.keys(state)) delete state[key];
+        return true;
+      }
+      const key = String(k);
+      const had = Object.prototype.hasOwnProperty.call(state, key);
+      if (had) delete state[key];
+      return had;
+    };
+
+    const debug = (...args) => {
+      try { if (debugEnabled) console.debug('[tgCore]', ...args); } catch {}
+    };
+    const setDebug = (v) => { debugEnabled = !!v; return debugEnabled; };
+    const getDebug = () => !!debugEnabled;
+
+    // Canonical event names for downstream files
+    const EVENTS = deepFreeze({
+      PERF_PROFILE: 'tg:perf-profile',
+      SIGNAL_FRESHNESS: 'tg:signal-freshness',
+      REPLY_READY: 'tg:reply-ready',
+      WARMUP_STAGE: 'tg:warmup-stage',
+      NOTIFY_HEALTH: 'tg:notify-health',
+      CORE_READY: 'tg:core-ready',
+      CORE_REUSED: 'tg:core-reused'
+    });
+
+    const knownEventSet = new Set(Object.values(EVENTS));
+
+    const isKnownEventName = (name) => {
+      const s = String(name || '');
+      return knownEventSet.has(s);
+    };
+
+    const diagnostics = () => ({
+      version: CORE_VERSION,
+      bootTs,
+      instanceId,
+      canonicals: Object.keys(canon).sort(),
+      owners: Object.assign({}, owners),
+      claimedGlobals: Object.assign({}, symbolOwners),
+      stateKeys: Object.keys(state).sort(),
+      listeners: Array.from(listeners.entries()).map(([k, v]) => ({ event: k, count: v.size }))
+    });
+
+    registerCanonical('load_json', loadJson, 'core-utils');
+    registerCanonical('stable_json_dumps', stableJsonDumps, 'core-utils');
+
+    root.__tgCore = Object.freeze({
+      version: CORE_VERSION,
+      bootTs,
+      instanceId,
+
+      registerCanonical,
+      blockDuplicateUtility,
+      claimGlobalSymbol,
+      releaseGlobalSymbol,
+      createPrivateName,
+
+      getCanonical: (name) => canon[name] || null,
+      getOwner: (name) => owners[name] || null,
+      listCanonicals: () => Object.keys(canon).sort(),
+
+      emit,
+      on,
+      off,
+
+      emitDom,
+      onDom,
+      emitBoth,
+      onAny,
+
+      setState,
+      getState,
+      snapshotState,
+      clearState,
+
+      EVENTS,
+      isKnownEventName,
+
+      diagnostics,
+
+      debug,
+      setDebug,
+      getDebug
+    });
+  }
+
+  root.__tgCoreVersion = CORE_VERSION;
+  root[GUARD_KEY] = true;
+
+  // Compatibility shim: legacy users of __tgBus route through canonical core DOM bridge.
+  if (!root.__tgBus) {
+    root.__tgBus = Object.freeze({
+      emit: (name, detail) => { try { root.__tgCore.emitDom(name, detail); } catch {} },
+      on: (name, fn, opt) => {
+        try { return root.__tgCore.onDom(name, fn, opt || { passive: true }); } catch { return () => {}; }
+      }
+    });
+  }
+
+  // Boot signal for deterministic downstream initialization.
+  try {
+    root.__tgCore.emitDom('tg:core-ready', {
+      ts: Date.now(),
+      version: root.__tgCore?.version || CORE_VERSION,
+      instanceId: root.__tgCore?.instanceId || '',
+      bootTs: root.__tgCore?.bootTs || 0
+    });
+  } catch {}
+})();

GPTTrafficgateUPDATEDv3.1/content/dom-softcap.js

@@ -0,0 +1,561 @@
+// content/dom-softcap.js — dynamic softcap per tab visibility (active vs background)
+// Updated: canonical owner guard + fixed perf-profile contract + deterministic trim queue + state surface
+// Patch: v2.1.0 reinjection-safe API, full lifecycle cleanup, generation-safe scheduling, richer diagnostics
+
+(() => {
+  'use strict';
+
+  const root = window;
+  const doc = document;
+  const OWNER = 'dom-softcap';
+  const VERSION = '2.1.0';
+  const GUARD_KEY = '__tgDomSoftcap_bootstrapped_v2';
+  const SYMBOL_NAME = 'tg-dom-softcap';
+  const SELECTOR_TURN = '[data-testid^="conversation-turn-"]';
+
+  if (root[GUARD_KEY] && root.__chatSoftCap) return;
+  if (root[GUARD_KEY] && !root.__chatSoftCap) {
+    // Bootstrapped marker exists without API; avoid duplicate init anyway.
+    return;
+  }
+  root[GUARD_KEY] = true;
+
+  const core = root.__tgCore || null;
+  const PERF_EVENT_NAME = String(core?.EVENTS?.PERF_PROFILE || 'tg:perf-profile');
+
+  try {
+    core?.claimGlobalSymbol?.(SYMBOL_NAME, OWNER, { allowTakeover: false });
+  } catch (e) {
+    try { if (root.__TG_DEBUG) console.warn('[dom-softcap] symbol claim blocked', e); } catch {}
+    return;
+  }
+
+  const tlog = (...args) => { try { root.__tgTelemetry?.apply(null, args); } catch {} };
+
+  const state = {
+    enabled: true,
+
+    // Effective knobs
+    keep: 60,           // computed effective keep
+    keepActive: 45,     // visible tab
+    keepHidden: 16,     // hidden tab
+    keepDeepHidden: 10, // hidden long enough
+
+    deepHiddenAfterMs: 3 * 60 * 1000,
+    hiddenSince: null,
+
+    container: null,
+    observer: null,
+
+    firstDone: false,
+    dirty: true,
+
+    lastTrim: 0,
+    trimQueued: false,
+    trimBatch: 12,
+    minTrimGapMs: 300,
+    trimGen: 0, // generation counter to invalidate stale queued callbacks
+
+    // lifecycle
+    hbTimer: null,
+    scheduleTimer: null,
+    placeholderTimer: null,
+    offCorePerf: null,
+    offDomPerf: null,
+    offVisibility: null,
+
+    // diagnostics
+    trimOps: 0,
+    totalRemoved: 0,
+    lastTurnCount: 0,
+    placeholderRemoved: 0,
+    lastProfile: '',
+    startedAt: 0,
+    stoppedAt: 0
+  };
+
+  function publishState(extra) {
+    try {
+      root.__tgSoftcapState = Object.assign({
+        version: VERSION,
+        owner: OWNER,
+        enabled: !!state.enabled,
+        keep: Number(state.keep || 0),
+        keepActive: Number(state.keepActive || 0),
+        keepHidden: Number(state.keepHidden || 0),
+        keepDeepHidden: Number(state.keepDeepHidden || 0),
+        deepHiddenAfterMs: Number(state.deepHiddenAfterMs || 0),
+        hiddenSince: Number(state.hiddenSince || 0),
+        visibility: doc.visibilityState,
+        hasContainer: !!state.container,
+        hasObserver: !!state.observer,
+        dirty: !!state.dirty,
+        trimQueued: !!state.trimQueued,
+        trimGen: Number(state.trimGen || 0),
+        trimBatch: Number(state.trimBatch || 0),
+        minTrimGapMs: Number(state.minTrimGapMs || 0),
+        trimOps: Number(state.trimOps || 0),
+        totalRemoved: Number(state.totalRemoved || 0),
+        lastTurnCount: Number(state.lastTurnCount || 0),
+        lastTrimMs: Number(state.lastTrim || 0),
+        placeholderRemoved: Number(state.placeholderRemoved || 0),
+        scheduleTimerArmed: !!state.scheduleTimer,
+        hbTimerArmed: !!state.hbTimer,
+        placeholderTimerArmed: !!state.placeholderTimer,
+        lastProfile: String(state.lastProfile || ''),
+        startedAt: Number(state.startedAt || 0),
+        stoppedAt: Number(state.stoppedAt || 0)
+      }, extra || {});
+    } catch {}
+  }
+
+  function clampKeep(v, min, max) {
+    const n = Number(v);
+    if (!Number.isFinite(n)) return min;
+    return Math.max(min, Math.min(max, Math.floor(n)));
+  }
+
+  function applyMode() {
+    const vis = doc.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 = doc.querySelector(SELECTOR_TURN);
+    if (!first) return null;
+
+    let p = first.parentElement;
+    while (p && p !== doc.body) {
+      const kids = Array.from(p.children).filter((el) => 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 && el.nodeType === 1);
+    return kids.length > 0 && kids.every((el) => el.matches(SELECTOR_TURN));
+  }
+
+  function nodes() {
+    if (!state.container) return [];
+    try {
+      return Array.from(state.container.querySelectorAll(SELECTOR_TURN));
+    } catch {
+      return [];
+    }
+  }
+
+  function doTrimWork() {
+    if (!state.enabled || !state.container) return;
+
+    applyMode();
+
+    const list = nodes();
+    const total = list.length;
+    state.lastTurnCount = total;
+
+    tlog('turnCount', { count: total, keep: state.keep, vis: doc.visibilityState });
+
+    const extra = total - state.keep;
+    if (extra > 0) {
+      const cutoff = total - state.keep;
+      const keepNodes = list.slice(cutoff);
+
+      let prevDisplay = '';
+      try {
+        prevDisplay = state.container.style.display;
+        state.container.style.display = 'none';
+      } catch {}
+
+      if (isPure(state.container)) {
+        try {
+          state.container.replaceChildren(...keepNodes);
+        } catch {
+          // fallback path if replaceChildren fails for any reason
+          for (let i = 0; i < cutoff; i++) {
+            try { list[i]?.remove(); } catch {}
+          }
+        }
+      } else {
+        // fallback for mixed container
+        for (let i = 0; i < cutoff; i++) {
+          try { list[i]?.remove(); } catch {}
+        }
+      }
+
+      try { state.container.style.display = prevDisplay; } catch {}
+      state.trimOps += 1;
+      state.totalRemoved += cutoff;
+
+      tlog('trim', { removed: cutoff, kept: state.keep });
+    }
+
+    state.lastTrim = Date.now();
+    state.dirty = false;
+    state.trimQueued = false;
+
+    // Preferred signal for early-shield to remove CSS shield
+    if (!state.firstDone) {
+      state.firstDone = true;
+      try { root.dispatchEvent(new Event('tg-unshield')); } catch {}
+    }
+
+    publishState();
+  }
+
+  function trimNowSafe() {
+    try { doTrimWork(); } catch {}
+  }
+
+  function clearScheduleTimer() {
+    if (state.scheduleTimer) {
+      try { clearTimeout(state.scheduleTimer); } catch {}
+      state.scheduleTimer = null;
+    }
+  }
+
+  function requestTrim(delayMs = 0) {
+    const now = Date.now();
+    const dt = now - (state.lastTrim || 0);
+
+    if (!state.enabled) {
+      state.trimQueued = false;
+      clearScheduleTimer();
+      publishState();
+      return;
+    }
+
+    if (state.trimQueued) return;
+
+    const effectiveDelay = Math.max(
+      Number(delayMs || 0),
+      dt < state.minTrimGapMs ? (state.minTrimGapMs - dt) : 0
+    );
+
+    state.trimQueued = true;
+    state.trimGen += 1;
+    const myGen = state.trimGen;
+
+    clearScheduleTimer();
+
+    state.scheduleTimer = setTimeout(() => {
+      state.scheduleTimer = null;
+
+      // stale callback guard
+      if (myGen !== state.trimGen) return;
+      if (!state.enabled) {
+        state.trimQueued = false;
+        publishState();
+        return;
+      }
+
+      try {
+        if ('requestIdleCallback' in root && typeof root.requestIdleCallback === 'function') {
+          root.requestIdleCallback(() => {
+            if (myGen !== state.trimGen) return;
+            trimNowSafe();
+          }, { timeout: 1200 });
+        } else {
+          trimNowSafe();
+        }
+      } catch {
+        trimNowSafe();
+      }
+    }, effectiveDelay);
+
+    publishState();
+  }
+
+  function bindContainerIfNeeded() {
+    const c = findContainer();
+    if (!c) return false;
+
+    if (state.container !== c) {
+      try { state.observer?.disconnect?.(); } catch {}
+
+      state.container = c;
+      state.dirty = true;
+
+      state.observer = new MutationObserver(() => {
+        if (!state.enabled) return;
+        state.dirty = true;
+        requestTrim(40);
+      });
+
+      try {
+        state.observer.observe(state.container, { childList: true });
+      } catch {}
+
+      requestTrim(80);
+      publishState({ rebound: true, reboundTs: Date.now() });
+    }
+
+    return true;
+  }
+
+  function heartbeat() {
+    if (!state.enabled) {
+      publishState();
+      return;
+    }
+    bindContainerIfNeeded();
+    if (state.dirty) requestTrim(80);
+    publishState();
+  }
+
+  function applySoftcapProfile(detail) {
+    const d = detail || {};
+    const profile = String(d.profile || '');
+
+    // If controller explicitly passes keep, trust it for active mode.
+    if (Number.isFinite(Number(d.keep))) {
+      state.keepActive = clampKeep(Number(d.keep), 20, 300);
+    }
+
+    // Optional explicit knobs from controller
+    if (Number.isFinite(Number(d.keepHidden))) {
+      state.keepHidden = clampKeep(Number(d.keepHidden), 8, 220);
+    }
+    if (Number.isFinite(Number(d.keepDeepHidden))) {
+      state.keepDeepHidden = clampKeep(Number(d.keepDeepHidden), 5, 120);
+    }
+    if (Number.isFinite(Number(d.deepHiddenAfterMs))) {
+      state.deepHiddenAfterMs = Math.max(10000, Math.floor(Number(d.deepHiddenAfterMs)));
+    }
+
+    // Contract compatibility signals
+    const streamFlag = (typeof d.streamActive === 'boolean')
+      ? d.streamActive
+      : (typeof d.streaming === 'boolean' ? d.streaming : null);
+    if (typeof streamFlag === 'boolean') {
+      // currently unused for trim logic, but captured for diagnostics/state surface if needed later
+    }
+
+    if (typeof d.visible === 'boolean') {
+      // hint only; visibilityState remains source of truth for mode
+    }
+
+    // Profile fallback mapping when explicit keep is absent
+    if (!Number.isFinite(Number(d.keep))) {
+      if (profile === 'hidden') {
+        state.keepActive = Math.min(state.keepActive, 16);
+      } else if (profile === 'recovery') {
+        state.keepActive = Math.min(state.keepActive, 28);
+      } else if (profile === 'flow') {
+        state.keepActive = clampKeep(state.keepActive, 36, 42);
+      } else if (profile === 'balanced') {
+        state.keepActive = Math.max(state.keepActive, 45);
+      }
+    }
+
+    state.lastProfile = profile || state.lastProfile || 'unknown';
+    state.dirty = true;
+    applyMode();
+    requestTrim(30);
+    publishState({ profileApplied: profile || 'unknown' });
+  }
+
+  function bindDomListeners() {
+    const onVis = () => {
+      applyMode();
+      state.dirty = true;
+      requestTrim(120);
+    };
+    doc.addEventListener('visibilitychange', onVis, { passive: true });
+    state.offVisibility = () => {
+      try { doc.removeEventListener('visibilitychange', onVis, { passive: true }); } catch {}
+    };
+
+    const onPerf = (ev) => {
+      try { applySoftcapProfile(ev?.detail || {}); } catch {}
+    };
+    root.addEventListener(PERF_EVENT_NAME, onPerf, { passive: true });
+    state.offDomPerf = () => {
+      try { root.removeEventListener(PERF_EVENT_NAME, onPerf, { passive: true }); } catch {}
+    };
+  }
+
+  function bindCoreListeners() {
+    try {
+      if (core?.on) {
+        state.offCorePerf = core.on(PERF_EVENT_NAME, (detail) => {
+          try { applySoftcapProfile(detail || {}); } catch {}
+        });
+      }
+    } catch {}
+  }
+
+  function setConfig(cfg) {
+    if (!cfg || typeof cfg !== 'object') return;
+
+    if (typeof cfg.enabled === 'boolean') state.enabled = cfg.enabled;
+    if (Number.isFinite(Number(cfg.keep))) state.keepActive = clampKeep(cfg.keep, 20, 300);
+    if (Number.isFinite(Number(cfg.keepHidden))) state.keepHidden = clampKeep(cfg.keepHidden, 8, 220);
+    if (Number.isFinite(Number(cfg.keepDeepHidden))) state.keepDeepHidden = clampKeep(cfg.keepDeepHidden, 5, 120);
+    if (Number.isFinite(Number(cfg.deepHiddenAfterMs))) state.deepHiddenAfterMs = Math.max(10000, Math.floor(Number(cfg.deepHiddenAfterMs)));
+    if (Number.isFinite(Number(cfg.minTrimGapMs))) state.minTrimGapMs = Math.max(50, Math.floor(Number(cfg.minTrimGapMs)));
+    if (Number.isFinite(Number(cfg.trimBatch))) state.trimBatch = Math.max(1, Math.floor(Number(cfg.trimBatch)));
+
+    state.dirty = true;
+    applyMode();
+    requestTrim(30);
+    publishState({ setConfig: true });
+  }
+
+  function diagnostics() {
+    return {
+      version: VERSION,
+      owner: OWNER,
+      enabled: !!state.enabled,
+      keep: {
+        effective: Number(state.keep || 0),
+        active: Number(state.keepActive || 0),
+        hidden: Number(state.keepHidden || 0),
+        deepHidden: Number(state.keepDeepHidden || 0),
+        deepHiddenAfterMs: Number(state.deepHiddenAfterMs || 0)
+      },
+      lifecycle: {
+        startedAt: Number(state.startedAt || 0),
+        stoppedAt: Number(state.stoppedAt || 0),
+        hbTimer: !!state.hbTimer,
+        scheduleTimer: !!state.scheduleTimer,
+        placeholderTimer: !!state.placeholderTimer
+      },
+      queue: {
+        dirty: !!state.dirty,
+        trimQueued: !!state.trimQueued,
+        trimGen: Number(state.trimGen || 0),
+        lastTrim: Number(state.lastTrim || 0),
+        minTrimGapMs: Number(state.minTrimGapMs || 0)
+      },
+      container: {
+        hasContainer: !!state.container,
+        hasObserver: !!state.observer,
+        lastTurnCount: Number(state.lastTurnCount || 0)
+      },
+      counters: {
+        trimOps: Number(state.trimOps || 0),
+        totalRemoved: Number(state.totalRemoved || 0),
+        placeholderRemoved: Number(state.placeholderRemoved || 0)
+      },
+      profile: String(state.lastProfile || '')
+    };
+  }
+
+  try {
+    Object.defineProperty(root, '__chatSoftCap', {
+      value: Object.freeze({
+        setConfig,
+        requestTrim: (delayMs = 0) => requestTrim(Number(delayMs || 0)),
+        diagnostics
+      }),
+      writable: false,
+      configurable: true,
+      enumerable: false
+    });
+  } catch {}
+
+  function startPlaceholderCleanup() {
+    if (state.placeholderTimer) return;
+    state.placeholderTimer = setInterval(() => {
+      try {
+        if (!state.enabled) return;
+        const ph = doc.querySelectorAll('.tg-recycle-placeholder');
+        if (ph.length > 800) {
+          const removeN = ph.length - 600;
+          for (let i = 0; i < removeN; i++) {
+            const n = ph[i];
+            if (n && n.parentNode) n.parentNode.removeChild(n);
+          }
+          state.placeholderRemoved += removeN;
+          publishState({ placeholderSweep: removeN });
+        }
+      } catch {}
+    }, 30000);
+  }
+
+  function stopPlaceholderCleanup() {
+    if (state.placeholderTimer) {
+      try { clearInterval(state.placeholderTimer); } catch {}
+      state.placeholderTimer = null;
+    }
+  }
+
+  function start() {
+    state.startedAt = Date.now();
+    bindDomListeners();
+    bindCoreListeners();
+
+    bindContainerIfNeeded();
+    applyMode();
+    requestTrim(160);
+
+    if (!state.hbTimer) {
+      state.hbTimer = setInterval(heartbeat, 2000);
+    }
+
+    startPlaceholderCleanup();
+    publishState({ startedAt: state.startedAt });
+  }
+
+  function teardown() {
+    state.stoppedAt = Date.now();
+
+    // invalidate queued trims
+    state.trimGen += 1;
+    state.trimQueued = false;
+
+    clearScheduleTimer();
+
+    try { if (state.hbTimer) clearInterval(state.hbTimer); } catch {}
+    state.hbTimer = null;
+
+    stopPlaceholderCleanup();
+
+    try { state.observer?.disconnect?.(); } catch {}
+    state.observer = null;
+    state.container = null;
+
+    try { state.offCorePerf?.(); } catch {}
+    state.offCorePerf = null;
+
+    try { state.offDomPerf?.(); } catch {}
+    state.offDomPerf = null;
+
+    try { state.offVisibility?.(); } catch {}
+    state.offVisibility = null;
+
+    publishState({ stoppedAt: state.stoppedAt, tornDown: true });
+  }
+
+  // Optional debug teardown
+  try {
+    Object.defineProperty(root, '__tgSoftcapTeardown', {
+      value: teardown,
+      writable: false,
+      configurable: true,
+      enumerable: false
+    });
+  } catch {}
+
+  if (doc.readyState === 'loading') {
+    doc.addEventListener('DOMContentLoaded', () => {
+      start();
+    }, { once: true });
+  } else {
+    start();
+  }
+})();

GPTTrafficgateUPDATEDv3.1/content/early-shield.js

@@ -0,0 +1,305 @@
+// content/early-shield.js — document_start CSS shield (auto-unshields safely)
+// Updated: canonical core integration + singleton guard + idempotent lifecycle
+// Patch: v1.2.0 reinjection-safe API, stronger cleanup, core lifecycle compat, richer diagnostics
+
+(() => {
+  'use strict';
+
+  const root = window;
+  const doc = document;
+  const VERSION = '1.2.0';
+  const OWNER = 'early-shield';
+  const GUARD_KEY = '__tgEarlyShield_bootstrapped_v1';
+  const SYMBOL_NAME = 'tg-early-shield';
+
+  const EVENTS = Object.freeze({
+    UNSHIELD: 'tg-unshield',
+    READY: 'tg-early-shield-ready',
+    REMOVED: 'tg-early-shield-removed',
+    CORE_READY: 'tg:core-ready',
+    CORE_REUSED: 'tg:core-reused'
+  });
+
+  // Reinjection-safe short-circuit if already initialized.
+  if (root[GUARD_KEY] && root.__tgEarlyShield) {
+    try { root.__tgEarlyShield?.diagnostics?.(); } catch {}
+    return;
+  }
+  root[GUARD_KEY] = true;
+
+  const core = root.__tgCore || null;
+
+  // Try to claim symbol if canonical core exists.
+  try {
+    core?.claimGlobalSymbol?.(SYMBOL_NAME, OWNER, { allowTakeover: false });
+  } catch (e) {
+    // If symbol claim fails, exit to avoid collisions with another owner.
+    try { if (root.__TG_DEBUG) console.warn('[early-shield] symbol claim blocked', e); } catch {}
+    return;
+  }
+
+  const state = {
+    active: false,
+    removed: false,
+    appliedAt: 0,
+    removedAt: 0,
+    removedReason: '',
+    timeoutId: null,
+
+    offCoreUnshield: null,
+    offCoreReady: null,
+    offCoreReused: null,
+
+    offDomUnshield: null,
+    offDomReady: null,
+
+    lastError: ''
+  };
+
+  let styleEl = null;
+
+  const safeDispatch = (name, detail) => {
+    try { root.dispatchEvent(new CustomEvent(name, { detail })); } catch {}
+  };
+
+  const setStatus = (extra = null) => {
+    try {
+      root.__tgEarlyShieldStatus = Object.assign({
+        version: VERSION,
+        owner: OWNER,
+        active: !!state.active,
+        removed: !!state.removed,
+        appliedAt: state.appliedAt || 0,
+        removedAt: state.removedAt || 0,
+        removedReason: state.removedReason || '',
+        lastError: state.lastError || ''
+      }, extra || {});
+    } catch {}
+  };
+
+  const setErr = (e) => {
+    try { state.lastError = String(e?.message || e || ''); } catch {}
+  };
+
+  const resolveMountTarget = () => {
+    return doc.documentElement || doc.head || doc.body || doc;
+  };
+
+  const ensureShieldStyle = () => {
+    styleEl = doc.getElementById('tg-early-shield');
+    if (styleEl) return styleEl;
+
+    const el = doc.createElement('style');
+    el.id = 'tg-early-shield';
+    el.setAttribute('data-owner', OWNER);
+    el.textContent = `
+      html.tg-shield [data-testid^="conversation-turn-"] { display: none !important; }
+      html.tg-shield [data-testid="conversation-turns"] { visibility: hidden !important; }
+    `;
+    resolveMountTarget().appendChild(el);
+    styleEl = el;
+    return styleEl;
+  };
+
+  const applyShield = () => {
+    if (state.active || state.removed) return false;
+
+    try {
+      ensureShieldStyle();
+      doc.documentElement?.classList?.add('tg-shield');
+
+      state.active = true;
+      state.appliedAt = Date.now();
+
+      setStatus();
+      safeDispatch(EVENTS.READY, {
+        active: true,
+        ts: state.appliedAt,
+        version: VERSION,
+        owner: OWNER
+      });
+
+      return true;
+    } catch (e) {
+      setErr(e);
+      setStatus();
+      return false;
+    }
+  };
+
+  const clearTimer = () => {
+    try {
+      if (state.timeoutId) clearTimeout(state.timeoutId);
+    } catch {}
+    state.timeoutId = null;
+  };
+
+  const clearListeners = () => {
+    try { state.offCoreUnshield?.(); } catch {}
+    state.offCoreUnshield = null;
+
+    try { state.offCoreReady?.(); } catch {}
+    state.offCoreReady = null;
+
+    try { state.offCoreReused?.(); } catch {}
+    state.offCoreReused = null;
+
+    try { state.offDomUnshield?.(); } catch {}
+    state.offDomUnshield = null;
+
+    try { state.offDomReady?.(); } catch {}
+    state.offDomReady = null;
+  };
+
+  const detachStyle = () => {
+    try {
+      if (styleEl && styleEl.parentNode) {
+        styleEl.parentNode.removeChild(styleEl);
+        styleEl = null;
+        return;
+      }
+    } catch {}
+    try {
+      const el = doc.getElementById('tg-early-shield');
+      if (el && el.parentNode) el.parentNode.removeChild(el);
+    } catch {}
+    styleEl = null;
+  };
+
+  const removeShield = (reason = 'unknown') => {
+    if (state.removed) return false;
+    state.removed = true;
+
+    clearTimer();
+    clearListeners();
+
+    try { doc.documentElement?.classList?.remove('tg-shield'); } catch {}
+    detachStyle();
+
+    state.active = false;
+    state.removedAt = Date.now();
+    state.removedReason = String(reason || 'unknown');
+
+    setStatus();
+    safeDispatch(EVENTS.REMOVED, {
+      active: false,
+      ts: state.removedAt,
+      reason: state.removedReason,
+      version: VERSION,
+      owner: OWNER
+    });
+
+    return true;
+  };
+
+  const diagnostics = () => ({
+    version: VERSION,
+    owner: OWNER,
+    state: {
+      active: !!state.active,
+      removed: !!state.removed,
+      appliedAt: state.appliedAt || 0,
+      removedAt: state.removedAt || 0,
+      removedReason: state.removedReason || '',
+      timeoutArmed: !!state.timeoutId,
+      lastError: state.lastError || ''
+    },
+    listeners: {
+      domUnshield: !!state.offDomUnshield,
+      domReady: !!state.offDomReady,
+      coreUnshield: !!state.offCoreUnshield,
+      coreReady: !!state.offCoreReady,
+      coreReused: !!state.offCoreReused
+    },
+    stylePresent: !!doc.getElementById('tg-early-shield'),
+    classPresent: !!doc.documentElement?.classList?.contains('tg-shield')
+  });
+
+  const bindDomUnshield = () => {
+    const handler = () => { removeShield('event:tg-unshield'); };
+    root.addEventListener(EVENTS.UNSHIELD, handler, { once: true, passive: true });
+    state.offDomUnshield = () => {
+      try { root.removeEventListener(EVENTS.UNSHIELD, handler, { passive: true }); } catch {}
+    };
+  };
+
+  const bindDomReadyFallback = () => {
+    if (doc.readyState === 'loading') {
+      const onReady = () => { removeShield('domcontentloaded'); };
+      doc.addEventListener('DOMContentLoaded', onReady, { once: true, passive: true });
+      state.offDomReady = () => {
+        try { doc.removeEventListener('DOMContentLoaded', onReady, { passive: true }); } catch {}
+      };
+    } else {
+      state.offDomReady = null;
+    }
+  };
+
+  const bindCorePaths = () => {
+    try {
+      if (!core?.on) return;
+
+      state.offCoreUnshield = core.on(EVENTS.UNSHIELD, () => {
+        removeShield('core:tg-unshield');
+      });
+
+      // Core lifecycle compatibility: republish status when core lifecycle events occur.
+      state.offCoreReady = core.on(EVENTS.CORE_READY, () => {
+        setStatus({ coreLifecycle: 'ready', coreTs: Date.now() });
+      });
+
+      state.offCoreReused = core.on(EVENTS.CORE_REUSED, () => {
+        setStatus({ coreLifecycle: 'reused', coreTs: Date.now() });
+      });
+    } catch (e) {
+      setErr(e);
+      setStatus();
+    }
+  };
+
+  const boot = () => {
+    try {
+      applyShield();
+
+      // Safety valve: auto-unshield after 2.5s even if no trim/unshield fired
+      state.timeoutId = setTimeout(() => {
+        removeShield('timeout');
+      }, 2500);
+
+      bindDomUnshield();
+      bindCorePaths();
+      bindDomReadyFallback();
+
+      setStatus({ bootedAt: Date.now() });
+    } catch (e) {
+      // Hard fail-safe: never leave page permanently shielded
+      setErr(e);
+      removeShield('exception');
+    }
+  };
+
+  // Stable API for debug/ops and reinjection-safe control.
+  try {
+    Object.defineProperty(root, '__tgEarlyShield', {
+      value: Object.freeze({
+        version: VERSION,
+        owner: OWNER,
+        state: () => ({
+          active: !!state.active,
+          removed: !!state.removed,
+          appliedAt: state.appliedAt || 0,
+          removedAt: state.removedAt || 0,
+          removedReason: state.removedReason || ''
+        }),
+        apply: () => applyShield(),
+        remove: (reason) => removeShield(String(reason || 'manual')),
+        diagnostics
+      }),
+      writable: false,
+      configurable: true,
+      enumerable: false
+    });
+  } catch {}
+
+  boot();
+})();

GPTTrafficgateUPDATEDv3.1/content/keepalive.js

@@ -0,0 +1,563 @@
+// content/keepalive.js — keep session warm; leader-only pinger; no auto-discard
+// Upgraded: pressure-aware cadence, global-budget hold integration, hidden-tab conservative mode,
+// and hard cap on cumulative keepalive work per minute.
+// Patched: unified listeners, internal scan throttle, deterministic lifecycle, bounded state surface.
+
+(function () {
+  'use strict';
+
+  const root = window;
+  const doc = document;
+  const api = (typeof browser !== 'undefined') ? browser : chrome;
+  const tlog = (...args) => { try { root.__tgTelemetry?.apply(null, args); } catch {} };
+
+  const VERSION = '2.2.0';
+  const GUARD_KEY = '__tgKeepalive_bootstrapped_v2';
+
+  if (root[GUARD_KEY] && root.__chatKeepalive) return;
+  if (root[GUARD_KEY]) return;
+  root[GUARD_KEY] = true;
+
+  let __tgProfile = 'balanced';
+  let __tgPressure = 0;
+  let __tgFollowerThrottle = false;
+
+  let globalBudget = { totalStreamers: 0, visibleStreamers: 0, followerHold: false };
+
+  const state = {
+    enabled: true,           // overall module on/off
+    pingEnabled: false,      // leader-only pings by default
+    role: 'follower',        // 'leader' | 'follower'
+    minutes: 7,
+    jitterPct: 0.18,
+    jitterSeed: Math.floor(Math.random() * 1000000),
+    autoReconnect: true,
+    allowReloads: false,     // SAFE DEFAULT: off
+    lastReload: 0,
+    chosenPath: null,
+    chosenPathTs: 0,
+
+    // Stability guards
+    followerSuspendUntil: 0,
+    maxOpsPerMin: 10,
+    minuteBucket: Math.floor(Date.now() / 60000),
+    opsThisMinute: 0,
+
+    // Diagnostics
+    attempts: 0,
+    ok: 0,
+    fail: 0,
+    lastPingTs: 0,
+    lastPingOk: false,
+    lastPingPath: '',
+    lastPingMs: 0,
+    lastError: '',
+
+    // lifecycle
+    timer: null,
+    visListenerAdded: false,
+    msgListenerAdded: false,
+    moStarted: false,
+    onlineListenerAdded: false,
+    teardownAt: 0,
+
+    // scan throttle
+    lastDisconnectScan: 0,
+    disconnectScanMinMs: 1200
+  };
+
+  function publishState(extra = null) {
+    try {
+      root.__tgKeepaliveState = Object.assign({
+        version: VERSION,
+        enabled: !!state.enabled,
+        pingEnabled: !!state.pingEnabled,
+        role: state.role,
+        profile: __tgProfile,
+        pressure: Number(__tgPressure || 0),
+        followerThrottle: !!__tgFollowerThrottle,
+        followerHold: !!globalBudget?.followerHold,
+        minutes: Number(state.minutes || 0),
+        jitterPct: Number(state.jitterPct || 0),
+        attempts: Number(state.attempts || 0),
+        ok: Number(state.ok || 0),
+        fail: Number(state.fail || 0),
+        minuteBucket: Number(state.minuteBucket || 0),
+        opsThisMinute: Number(state.opsThisMinute || 0),
+        maxOpsPerMin: Number(state.maxOpsPerMin || 0),
+        chosenPath: state.chosenPath || '',
+        chosenPathTs: Number(state.chosenPathTs || 0),
+        lastPingTs: Number(state.lastPingTs || 0),
+        lastPingOk: !!state.lastPingOk,
+        lastPingPath: state.lastPingPath || '',
+        lastPingMs: Number(state.lastPingMs || 0),
+        lastError: state.lastError || '',
+        timerArmed: !!state.timer
+      }, extra || {});
+    } catch {}
+  }
+
+  function resetMinuteBucketIfNeeded() {
+    const m = Math.floor(Date.now() / 60000);
+    if (state.minuteBucket !== m) {
+      state.minuteBucket = m;
+      state.opsThisMinute = 0;
+    }
+  }
+
+  function canDoWorkNow() {
+    resetMinuteBucketIfNeeded();
+    return state.opsThisMinute < state.maxOpsPerMin;
+  }
+
+  function markWork() {
+    resetMinuteBucketIfNeeded();
+    state.opsThisMinute += 1;
+  }
+
+  function isFollowerHeld() {
+    if (state.role === 'leader') return false;
+    if (__tgFollowerThrottle) return true;
+    if (globalBudget?.followerHold) return true;
+    if (Date.now() < state.followerSuspendUntil) return true;
+    return false;
+  }
+
+  function dynamicBaseMinutes() {
+    let m = Math.max(2, Math.min(30, Number(state.minutes) || 7));
+    const p = Number(__tgPressure || 0);
+
+    if (doc.visibilityState !== 'visible') m = Math.max(m, 10);
+    if (isFollowerHeld()) m = Math.max(m, 14);
+    if (p >= 80) m = Math.max(m, 16);
+    else if (p >= 60) m = Math.max(m, 12);
+    else if (p >= 45) m = Math.max(m, 9);
+
+    if (__tgProfile === 'recovery') m = Math.max(m, 14);
+    if (__tgProfile === 'hidden') m = Math.max(m, 12);
+
+    return m;
+  }
+
+  function visible() { return doc.visibilityState === 'visible'; }
+
+  function notTyping() {
+    const ae = doc.activeElement;
+    return !(ae && (
+      ae.tagName === 'TEXTAREA' ||
+      (ae.tagName === 'INPUT' && /text|search|url|email|password/.test(ae.type || ''))
+    ));
+  }
+
+  function throttledTryClickRetry() {
+    const now = Date.now();
+    if ((now - state.lastDisconnectScan) < state.disconnectScanMinMs) return false;
+    state.lastDisconnectScan = now;
+    return tryClickRetry();
+  }
+
+  function tryClickRetry() {
+    const labels = ['reload', 'retry', 'try again', 'reconnect'];
+    const btns = Array.from(doc.querySelectorAll('button, a[role="button"]'));
+    for (const b of btns) {
+      const t = (b.textContent || '').trim().toLowerCase();
+      if (labels.some((L) => t.includes(L))) {
+        try { b.click(); } catch {}
+        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();
+  }
+
+  function clearTimer() {
+    if (state.timer) {
+      try { clearInterval(state.timer); } catch {}
+      state.timer = null;
+    }
+  }
+
+  async function pickEndpoint() {
+    // cool down endpoint picking; don't spam probes
+    if (state.chosenPath && (Date.now() - state.chosenPathTs) < 5 * 60 * 1000) return state.chosenPath;
+
+    const candidates = [
+      '/api/auth/session',
+      '/backend-api/models',
+      '/backend-api/conversations?offset=0&limit=1',
+      '/favicon.ico',
+      '/'
+    ];
+
+    for (const path of candidates) {
+      try {
+        if (!canDoWorkNow()) break;
+        markWork();
+        if (await headOrGet(path)) {
+          state.chosenPath = path;
+          state.chosenPathTs = Date.now();
+          publishState();
+          return path;
+        }
+      } catch {}
+    }
+    state.chosenPath = state.chosenPath || '/';
+    state.chosenPathTs = Date.now();
+    publishState();
+    return state.chosenPath;
+  }
+
+  async function headOrGet(path) {
+    const url = new URL(path, location.origin).toString();
+
+    // Hidden + held followers should stay light.
+    if (doc.visibilityState !== 'visible' && isFollowerHeld()) {
+      try {
+        if ('sendBeacon' in navigator) {
+          const blob = new Blob([], { type: 'application/octet-stream' });
+          navigator.sendBeacon(url, blob);
+          return true;
+        }
+      } catch {}
+      return false;
+    }
+
+    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 (doc.visibilityState !== 'visible' && 'sendBeacon' in navigator) {
+        const blob = new Blob([], { type: 'application/octet-stream' });
+        navigator.sendBeacon(url, blob);
+        return true;
+      }
+    } catch {}
+
+    return false;
+  }
+
+  function schedule() {
+    clearTimer();
+
+    if (!state.enabled || !state.pingEnabled) {
+      publishState();
+      return;
+    }
+
+    // hard hold for followers
+    if (isFollowerHeld()) {
+      publishState({ held: true });
+      return;
+    }
+
+    const baseMin = dynamicBaseMinutes();
+    const jitterLow = Math.max(0.20, 0.25 - (state.jitterPct * 0.1));
+    const jitterHigh = Math.min(0.55, 0.35 + state.jitterPct);
+    const jitter = jitterLow + Math.random() * (jitterHigh - jitterLow);
+    const ms = Math.floor(baseMin * jitter * 60000);
+
+    state.timer = setInterval(() => { ping().catch(() => {}); }, ms);
+
+    if (!state.visListenerAdded) {
+      state.visListenerAdded = true;
+      const onVis = () => {
+        if (doc.visibilityState === 'visible') {
+          api.runtime.sendMessage({ type: 'becomeLeader' }).catch(() => {});
+          if (state.role !== 'leader') {
+            // temporary follow-mode ping until role catches up
+            state.pingEnabled = true;
+          }
+          schedule();
+          setTimeout(() => { ping().catch(() => {}); }, 1200);
+        } else {
+          if (state.role !== 'leader') {
+            state.pingEnabled = false;
+          }
+          schedule();
+        }
+      };
+      doc.addEventListener('visibilitychange', onVis, { passive: true });
+      state._onVis = onVis;
+    }
+
+    setTimeout(() => { ping().catch(() => {}); }, 2500);
+    publishState({ scheduledMs: ms, baseMin });
+  }
+
+  async function ping() {
+    if (!state.enabled || !state.pingEnabled) return;
+    if (isFollowerHeld()) return;
+    if (!canDoWorkNow()) return;
+
+    state.attempts += 1;
+    markWork();
+
+    if (!state.chosenPath) state.chosenPath = await pickEndpoint();
+
+    let ok = false;
+    const t0 = performance.now();
+    try {
+      ok = await headOrGet(state.chosenPath);
+      if (ok) state.ok += 1;
+      else state.fail += 1;
+
+      state.lastPingTs = Date.now();
+      state.lastPingOk = !!ok;
+      state.lastPingPath = state.chosenPath || '';
+      state.lastPingMs = Math.round(performance.now() - t0);
+
+      tlog('ping', {
+        role: state.role,
+        ok,
+        pressure: __tgPressure,
+        profile: __tgProfile,
+        held: isFollowerHeld(),
+        opsThisMinute: state.opsThisMinute
+      });
+    } catch (e) {
+      state.fail += 1;
+      state.lastError = String(e?.message || e || 'ping_error');
+      state.lastPingTs = Date.now();
+      state.lastPingOk = false;
+      state.lastPingPath = state.chosenPath || '';
+      state.lastPingMs = Math.round(performance.now() - t0);
+    }
+
+    publishState();
+  }
+
+  function attachRuntimeMessageListener() {
+    if (state.msgListenerAdded) return;
+    state.msgListenerAdded = true;
+
+    const handler = (msg) => {
+      if (!msg) return;
+
+      if (msg.type === 'tgGlobalBudget') {
+        globalBudget = msg.budget || globalBudget;
+
+        // budget-aware hold: hidden followers should stop pinging immediately
+        if (globalBudget?.followerHold && doc.visibilityState !== 'visible' && state.role !== 'leader') {
+          state.pingEnabled = false;
+        }
+        schedule();
+        publishState({ budgetUpdate: true });
+        return;
+      }
+
+      if (msg.type === 'tgRole') {
+        state.role = (msg.role === 'leader') ? 'leader' : 'follower';
+        state.pingEnabled = (state.role === 'leader');
+        schedule();
+        publishState({ roleUpdate: state.role });
+      }
+    };
+
+    try {
+      api.runtime.onMessage.addListener(handler);
+      state._onRuntime = handler;
+    } catch {}
+  }
+
+  function attachPerfListener() {
+    const onPerf = (ev) => {
+      try {
+        __tgProfile = ev?.detail?.profile || __tgProfile;
+        __tgPressure = Number(ev?.detail?.pressure || __tgPressure || 0);
+        __tgFollowerThrottle = !!ev?.detail?.followerThrottle;
+        schedule();
+        publishState({ perfUpdate: true });
+      } catch {}
+    };
+    root.addEventListener('tg:perf-profile', onPerf, { passive: true });
+    state._onPerf = onPerf;
+  }
+
+  function attachReconnectObservers() {
+    if (!state.moStarted) {
+      state.moStarted = true;
+      const kw = /(trying to reconnect|attempting to connect|reconnecting|network error|disconnected|lost connection)/i;
+      state._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 (!throttledTryClickRetry() && state.allowReloads) {
+                  setTimeout(() => softReload(), 2500);
+                }
+                return;
+              }
+            }
+          }
+        }
+      });
+      try {
+        state._moErr.observe(doc.documentElement || doc.body, { childList: true, subtree: true });
+      } catch {}
+    }
+
+    if (!state.onlineListenerAdded) {
+      state.onlineListenerAdded = true;
+      const onOnline = () => {
+        if (state.autoReconnect && state.allowReloads) {
+          setTimeout(() => { if (!throttledTryClickRetry()) softReload(); }, 1200);
+        }
+      };
+      root.addEventListener('online', onOnline, { passive: true });
+      state._onOnline = onOnline;
+    }
+  }
+
+  function exposeApi() {
+    Object.defineProperty(root, '__chatKeepalive', {
+      value: Object.freeze({
+        setEnabled(v) { state.enabled = !!v; schedule(); publishState(); },
+        setMinutes(m) {
+          m = Math.max(4, Math.min(30, Math.floor(m || state.minutes)));
+          state.minutes = m;
+          schedule();
+          publishState();
+        },
+        setJitterPct(v) {
+          const n = Number(v);
+          if (Number.isFinite(n)) state.jitterPct = Math.max(0, Math.min(0.5, n));
+          publishState();
+        },
+        setAutoReconnect(v) { state.autoReconnect = !!v; publishState(); },
+        setAllowReloads(v) { state.allowReloads = !!v; publishState(); },
+        setPingEnabled(v) { state.pingEnabled = !!v; schedule(); publishState(); },
+        setRole(r) {
+          state.role = (r === 'leader') ? 'leader' : 'follower';
+          state.pingEnabled = (state.role === 'leader');
+          schedule();
+          publishState();
+        },
+        reconnectNow() { throttledTryClickRetry() || (state.allowReloads && softReload()); },
+        getHealth() {
+          return {
+            role: state.role,
+            enabled: state.enabled,
+            pingEnabled: state.pingEnabled,
+            attempts: state.attempts,
+            ok: state.ok,
+            fail: state.fail,
+            opsThisMinute: state.opsThisMinute,
+            minuteBucket: state.minuteBucket,
+            profile: __tgProfile,
+            pressure: __tgPressure,
+            followerThrottle: __tgFollowerThrottle,
+            followerHold: !!globalBudget?.followerHold
+          };
+        }
+      }),
+      writable: false, configurable: true, enumerable: false
+    });
+  }
+
+  function exposeTeardown() {
+    Object.defineProperty(root, '__tgKeepaliveTeardown', {
+      value: () => {
+        try { clearTimer(); } catch {}
+
+        try {
+          if (state._onPerf) root.removeEventListener('tg:perf-profile', state._onPerf, { passive: true });
+        } catch {}
+        state._onPerf = null;
+
+        try {
+          if (state._onVis) doc.removeEventListener('visibilitychange', state._onVis, { passive: true });
+        } catch {}
+        state._onVis = null;
+
+        try {
+          if (state._onOnline) root.removeEventListener('online', state._onOnline, { passive: true });
+        } catch {}
+        state._onOnline = null;
+
+        try { state._moErr?.disconnect?.(); } catch {}
+        state._moErr = null;
+
+        state.teardownAt = Date.now();
+        publishState({ teardownAt: state.teardownAt });
+      },
+      writable: false,
+      configurable: true,
+      enumerable: false
+    });
+  }
+
+  (async () => {
+    exposeApi();
+    exposeTeardown();
+    attachPerfListener();
+    attachRuntimeMessageListener();
+    attachReconnectObservers();
+
+    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 = (doc.visibilityState === 'visible');
+      }
+    } catch {
+      state.pingEnabled = (doc.visibilityState === 'visible');
+    }
+
+    // If visible, nudge background to elect us leader.
+    if (doc.visibilityState === 'visible') {
+      api.runtime.sendMessage({ type: 'becomeLeader' }).catch(() => {});
+    }
+
+    schedule();
+    publishState({ bootedAt: Date.now() });
+  })();
+})();

GPTTrafficgateUPDATEDv3.1/content/net-guard.js

@@ -0,0 +1,621 @@
+// content/net-guard.js — document_start guard with SAFE JSON thinning + safer soft-block for list pagination
+// Updated: canonical owner guard + unified fetch wrapper telemetry + clean event surface + bounded state
+// Patch: v2.1.0 safer blocked-fetch semantics (no unintended retry), core-ready/reused compat, richer diagnostics
+(() => {
+  'use strict';
+
+  const root = window;
+  const doc = document;
+  const OWNER = 'net-guard';
+  const VERSION = '2.1.0';
+  const GUARD_KEY = '__tgNetGuard_bootstrapped_v2';
+  const SYMBOL_NAME = 'tg-net-guard';
+
+  if (root[GUARD_KEY]) return;
+  root[GUARD_KEY] = true;
+
+  const core = root.__tgCore || null;
+  try {
+    core?.claimGlobalSymbol?.(SYMBOL_NAME, OWNER, { allowTakeover: false });
+  } catch (e) {
+    try { if (root.__TG_DEBUG) console.warn('[net-guard] symbol claim blocked', e); } catch {}
+    return;
+  }
+
+  const HOSTS = /^(chat\.openai\.com|chatgpt\.com)$/;
+  const PATHS = /(backend-api\/conversation|backend-api\/conversations|backend-api\/messages|\/history|\/messages|\/conversation|\/threads|\/v1\/messages|\/v1\/threads)/i;
+
+  // Base tuning
+  const KEEP_BASE = 45;
+  const KEEP_LOW = 24;
+  const KEEP_MID = 34;
+  const PARSE_BUDGET_BASE_MS = 22;
+  const MIN_THIN_BYTES = 250 * 1024;
+
+  // Hard cap for cumulative background work/minute
+  const MAX_THINS_PER_MIN = 18;
+
+  // 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 };
+
+  // Live perf/profile signal from autopilot
+  const perf = {
+    pressure: 0,
+    profile: 'balanced',
+    streamActive: false,
+    visible: doc.visibilityState === 'visible',
+    followerThrottle: false,
+    updatedAt: 0
+  };
+
+  const thinWindow = {
+    minute: Math.floor(Date.now() / 60000),
+    count: 0
+  };
+
+  const state = {
+    intervalId: null,
+    offCorePerf: null,
+    offCoreReady: null,
+    offCoreReused: null,
+
+    blocks: 0,
+    fetchBlocks: 0,
+    xhrBlocks: 0,
+    softBlocks: 0,
+    softBlockResponses: 0,
+    fetchAborts: 0,
+
+    thinApplied: 0,
+    thinSkipped: 0,
+    thinErrors: 0,
+
+    lastBlockUrl: '',
+    lastSlowFetchMs: 0,
+    lastError: '',
+    lastErrorTs: 0
+  };
+
+  const tlog = (...args) => { try { root.__tgTelemetry?.apply(null, args); } catch {} };
+
+  function setLastError(errLike) {
+    try {
+      state.lastError = String(errLike?.message || errLike || '');
+      state.lastErrorTs = Date.now();
+    } catch {}
+  }
+
+  function publishState(extra) {
+    try {
+      root.__tgNetGuardState = Object.assign({
+        version: VERSION,
+        owner: OWNER,
+        enabled: !!gate.enabled,
+        intent: !!gate.intent,
+        allowUntil: Number(gate.allowUntil || 0),
+
+        profile: String(perf.profile || 'balanced'),
+        pressure: Number(perf.pressure || 0),
+        streamActive: !!perf.streamActive,
+        visible: !!perf.visible,
+        followerThrottle: !!perf.followerThrottle,
+        updatedAt: Number(perf.updatedAt || 0),
+
+        thinMinute: thinWindow.minute,
+        thinMinuteCount: thinWindow.count,
+
+        blocks: state.blocks,
+        fetchBlocks: state.fetchBlocks,
+        xhrBlocks: state.xhrBlocks,
+        softBlocks: state.softBlocks,
+        softBlockResponses: state.softBlockResponses,
+        fetchAborts: state.fetchAborts,
+
+        thinApplied: state.thinApplied,
+        thinSkipped: state.thinSkipped,
+        thinErrors: state.thinErrors,
+
+        lastBlockUrl: state.lastBlockUrl || '',
+        lastSlowFetchMs: state.lastSlowFetchMs || 0,
+        lastError: state.lastError || '',
+        lastErrorTs: Number(state.lastErrorTs || 0)
+      }, extra || {});
+    } catch {}
+  }
+
+  function nowMinute() { return Math.floor(Date.now() / 60000); }
+
+  function bumpThinCounter() {
+    const m = nowMinute();
+    if (thinWindow.minute !== m) {
+      thinWindow.minute = m;
+      thinWindow.count = 0;
+    }
+    thinWindow.count += 1;
+  }
+
+  function canThinNow() {
+    const m = nowMinute();
+    if (thinWindow.minute !== m) {
+      thinWindow.minute = m;
+      thinWindow.count = 0;
+    }
+    return thinWindow.count < MAX_THINS_PER_MIN;
+  }
+
+  function parseBudgetMs() {
+    const p = Number(perf.pressure || 0);
+    if (p >= 80) return 10;
+    if (p >= 60) return 14;
+    if (p >= 45) return 18;
+    return PARSE_BUDGET_BASE_MS;
+  }
+
+  function dynamicKeep() {
+    const p = Number(perf.pressure || 0);
+    if (p >= 80) return KEEP_LOW;
+    if (p >= 55) return KEEP_MID;
+    return KEEP_BASE;
+  }
+
+  function overParseBudget(startTs) {
+    try { return (performance.now() - startTs) > parseBudgetMs(); } catch { return false; }
+  }
+
+  function shouldDeferHeavyWork() {
+    // Defer in hidden tabs when pressure/follower throttle is high.
+    if (doc.visibilityState === 'visible') return false;
+    if (perf.followerThrottle) return true;
+    if (Number(perf.pressure || 0) >= 55) return true;
+    return false;
+  }
+
+  async function syncGateStatus() {
+    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);
+        publishState();
+      }
+    } catch (e) {
+      setLastError(e);
+      publishState();
+    }
+  }
+
+  (async () => {
+    try {
+      const s = await api.storage.local.get({ blockHistory: true });
+      gate.enabled = !!s.blockHistory;
+    } catch (e) {
+      setLastError(e);
+    }
+    await syncGateStatus();
+    publishState();
+  })();
+
+  // Keep gate in sync without hammering runtime messaging
+  state.intervalId = setInterval(() => { syncGateStatus().catch(() => {}); }, 12000);
+
+  function absorbPerfDetail(d) {
+    try {
+      perf.profile = String(d.profile || perf.profile || 'balanced');
+      perf.pressure = Number(d.pressure || perf.pressure || 0);
+      perf.streamActive = !!d.streamActive;
+      perf.visible = (typeof d.visible === 'boolean') ? d.visible : (doc.visibilityState === 'visible');
+      perf.followerThrottle = !!d.followerThrottle;
+      perf.updatedAt = Date.now();
+      publishState();
+    } catch (e) {
+      setLastError(e);
+      publishState();
+    }
+  }
+
+  root.addEventListener('tg:perf-profile', (ev) => {
+    absorbPerfDetail(ev?.detail || {});
+  }, { passive: true });
+
+  // Canonical bus path (if core exists)
+  try {
+    if (core?.on) {
+      state.offCorePerf = core.on('tg:perf-profile', (detail) => absorbPerfDetail(detail || {}));
+
+      // Core lifecycle compat: republish local state so downstream sees coherent snapshot.
+      state.offCoreReady = core.on('tg:core-ready', () => {
+        publishState({ coreLifecycle: 'ready', coreTs: Date.now() });
+      });
+
+      state.offCoreReused = core.on('tg:core-reused', () => {
+        publishState({ coreLifecycle: 'reused', coreTs: Date.now() });
+      });
+    }
+  } catch {}
+
+  Object.defineProperty(root, '__chatTrafficGate', {
+    value: {
+      setEnabled(v) { gate.enabled = !!v; publishState(); },
+      setIntent(v) { gate.intent = !!v; publishState(); },
+      allowForMs(ms) {
+        gate.allowUntil = Date.now() + Math.max(2000, Math.min(60000, Number(ms) || 10000));
+        publishState();
+      }
+    },
+    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() {
+    // Generic empty page response for list-like pagination endpoints.
+    const body = JSON.stringify({ items: [], has_more: false });
+    state.softBlockResponses += 1;
+    return new Response(body, {
+      status: 200,
+      headers: { 'content-type': 'application/json; charset=utf-8' }
+    });
+  }
+
+  function thinMappingWithAncestors(data, keepN) {
+    try {
+      const mapping = data?.mapping;
+      if (!mapping || typeof mapping !== 'object') return { data, changed: false };
+      const ids = Object.keys(mapping);
+      if (ids.length <= keepN + 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(-keepN).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) {
+    const startTs = performance.now();
+    try {
+      // Don’t spend heavy CPU while hidden under pressure/follower hold.
+      if (shouldDeferHeavyWork()) {
+        state.thinSkipped += 1;
+        publishState();
+        return res;
+      }
+
+      // Cumulative work guard
+      if (!canThinNow()) {
+        state.thinSkipped += 1;
+        publishState();
+        return res;
+      }
+
+      const ct = res.headers.get('content-type') || '';
+      if (!/application\/json|json/i.test(ct)) return res;
+
+      const clen = Number(res.headers.get('content-length') || 0);
+      if (clen > 0 && clen < MIN_THIN_BYTES) return res;
+
+      const clone = res.clone();
+
+      // Parse budget fail-open
+      if (overParseBudget(startTs)) {
+        state.thinSkipped += 1;
+        publishState();
+        return res;
+      }
+
+      const t0 = performance.now();
+      const data = await clone.json();
+      if (overParseBudget(t0)) {
+        state.thinSkipped += 1;
+        publishState();
+        return res;
+      }
+
+      if (overParseBudget(startTs)) {
+        state.thinSkipped += 1;
+        publishState();
+        return res;
+      }
+
+      let changed = false;
+      const KEEP = dynamicKeep();
+
+      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, KEEP);
+        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;
+      if (overParseBudget(startTs)) {
+        state.thinSkipped += 1;
+        publishState();
+        return res; // fail-open late gate too
+      }
+
+      bumpThinCounter();
+      state.thinApplied += 1;
+
+      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);
+      publishState();
+      return new Response(body, { status: res.status, statusText: res.statusText, headers });
+    } catch (e) {
+      state.thinErrors += 1;
+      setLastError(e);
+      publishState();
+      // strict fail-open
+      return res;
+    }
+  }
+
+  function makeBlockedAbortError() {
+    const err = new DOMException('Blocked by Chat Traffic Gate', 'AbortError');
+    try { err.__tgBlocked = true; } catch {}
+    return err;
+  }
+
+  function isBlockedAbortError(e) {
+    if (!e) return false;
+    if (e.__tgBlocked === true) return true;
+    if (e.name === 'AbortError' && /Blocked by Chat Traffic Gate/i.test(String(e.message || ''))) return true;
+    return false;
+  }
+
+  function extractUrlFromFetchInput(input) {
+    try {
+      if (!input) return '';
+      if (typeof input === 'string') return input;
+      if (typeof URL !== 'undefined' && input instanceof URL) return input.href;
+      if (typeof input === 'object') {
+        if (typeof input.url === 'string') return input.url;
+        if (typeof input.href === 'string') return input.href;
+      }
+    } catch {}
+    try { return String(input); } catch { return ''; }
+  }
+
+  const _fetch = root.fetch;
+  if (typeof _fetch === 'function') {
+    root.fetch = async function patchedFetch(input, init) {
+      const fetchStart = performance.now();
+      const method = ((init && init.method) || 'GET').toUpperCase();
+      const url = extractUrlFromFetchInput(input);
+
+      try {
+        if (shouldBlock(method, url)) {
+          state.blocks += 1;
+          state.fetchBlocks += 1;
+          state.lastBlockUrl = String(url || '');
+          tlog('historyCancel');
+
+          // Prefer soft-block for list pagination: keeps UI calmer than an AbortError.
+          if (isSoftBlockCandidate(url)) {
+            state.softBlocks += 1;
+            publishState();
+            return softBlockResponse();
+          }
+
+          publishState();
+          throw makeBlockedAbortError();
+        }
+
+        const res = await _fetch.apply(this, arguments);
+
+        // Thin only paginated history responses (when allowed)
+        const out = looksHistory(url) ? await thinIfNeeded(res) : res;
+
+        const dt = performance.now() - fetchStart;
+        if (dt > 1200) {
+          state.lastSlowFetchMs = Math.round(dt);
+          try { root.__tgTelemetry && root.__tgTelemetry('slowFetch', { ms: state.lastSlowFetchMs }); } catch {}
+          publishState();
+        }
+
+        return out;
+      } catch (e) {
+        if (isBlockedAbortError(e)) {
+          state.fetchAborts += 1;
+          publishState();
+          throw e;
+        }
+
+        // Fail-open path for unexpected wrapper errors: attempt native fetch once.
+        try {
+          return await _fetch.apply(this, arguments);
+        } catch (nativeErr) {
+          setLastError(nativeErr || e);
+          publishState();
+          throw nativeErr;
+        }
+      }
+    };
+  }
+
+  const XHR = root.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)) {
+          state.blocks += 1;
+          state.xhrBlocks += 1;
+          state.lastBlockUrl = String(this.__tgURL || '');
+          try { this.abort(); } catch {}
+          try { this.dispatchEvent(new Event('error')); } catch {}
+          tlog('historyCancel');
+          publishState();
+          return;
+        }
+      } catch (e) {
+        setLastError(e);
+        publishState();
+      }
+      return _send.apply(this, arguments);
+    };
+  }
+
+  function diagnostics() {
+    return {
+      version: VERSION,
+      owner: OWNER,
+      gate: {
+        enabled: !!gate.enabled,
+        intent: !!gate.intent,
+        allowUntil: Number(gate.allowUntil || 0)
+      },
+      perf: {
+        profile: String(perf.profile || 'balanced'),
+        pressure: Number(perf.pressure || 0),
+        streamActive: !!perf.streamActive,
+        visible: !!perf.visible,
+        followerThrottle: !!perf.followerThrottle,
+        updatedAt: Number(perf.updatedAt || 0)
+      },
+      counters: {
+        blocks: state.blocks,
+        fetchBlocks: state.fetchBlocks,
+        xhrBlocks: state.xhrBlocks,
+        softBlocks: state.softBlocks,
+        softBlockResponses: state.softBlockResponses,
+        fetchAborts: state.fetchAborts,
+        thinApplied: state.thinApplied,
+        thinSkipped: state.thinSkipped,
+        thinErrors: state.thinErrors
+      },
+      last: {
+        lastBlockUrl: state.lastBlockUrl || '',
+        lastSlowFetchMs: state.lastSlowFetchMs || 0,
+        lastError: state.lastError || '',
+        lastErrorTs: Number(state.lastErrorTs || 0)
+      },
+      thinWindow: {
+        minute: thinWindow.minute,
+        count: thinWindow.count
+      }
+    };
+  }
+
+  function teardown() {
+    try { if (state.intervalId) clearInterval(state.intervalId); } catch {}
+    state.intervalId = null;
+    try { state.offCorePerf?.(); } catch {}
+    state.offCorePerf = null;
+    try { state.offCoreReady?.(); } catch {}
+    state.offCoreReady = null;
+    try { state.offCoreReused?.(); } catch {}
+    state.offCoreReused = null;
+  }
+
+  // Optional debug teardown hook
+  try {
+    Object.defineProperty(root, '__tgNetGuardTeardown', {
+      value: teardown,
+      writable: false,
+      configurable: true,
+      enumerable: false
+    });
+  } catch {}
+
+  // Optional debug diagnostics hook
+  try {
+    Object.defineProperty(root, '__tgNetGuardDiagnostics', {
+      value: diagnostics,
+      writable: false,
+      configurable: true,
+      enumerable: false
+    });
+  } catch {}
+
+  publishState({ bootedAt: Date.now() });
+})();

GPTTrafficgateUPDATEDv3.1/content/traffic-ui.js

@@ -0,0 +1,486 @@
+(function () {
+  'use strict';
+
+  const api = (typeof browser !== 'undefined') ? browser : chrome;
+
+  const status = {
+    profile: 'balanced',
+    pressure: 0,
+    streamers: 0,
+    visibleStreamers: 0,
+    blockHistory: true,
+    allowUntil: 0,
+    role: 'follower',
+    followerThrottle: false
+  };
+
+  const health = {
+    sent: 0,
+    failed: 0,
+    retried: 0,
+    fallback: 0,
+    suppressed: 0,
+    queueDepth: 0,
+    queueOldestAgeMs: 0,
+    queueNewestAgeMs: 0,
+    lastOkTs: 0,
+    lastError: '',
+    role: 'follower',
+    signals: 0,
+    detected: 0,
+    enqueued: 0,
+
+    detectorMisses: 0,
+    lastStreamEndTs: 0,
+    lastEventId: '',
+    lastNotifyVia: '',
+    lastSignalAgeMs: 0,
+    lastDetectedAgeMs: 0,
+    lastSeenFreshKind: ''
+  };
+
+  const freshness = {
+    lastSignalTs: 0,
+    lastDetectedTs: 0,
+    lastNotifyTs: 0,
+    lastHealthTs: 0,
+    lastStreamEndTs: 0,
+    lastHeartbeatTs: 0,
+    heartbeatAgeMs: 0
+  };
+
+  const ui = {
+    paused: false,
+    hiddenPanel: false
+  };
+
+  const ledger = [];
+  let stale = false;
+  let pill, panel, stateChip, statsBox, eventsBox, gateBtn, allowBtn, testBtn, refreshBtn, togglePanelBtn, pauseBtn, clearBtn;
+
+  const STALE_SIGNAL_MS = 18000;
+  const STALE_HEALTH_MS = 20000;
+  const QUIET_DETECT_MS = 30000;
+
+  function mk(tag) { return document.createElement(tag); }
+
+  function ago(ts) {
+    if (!ts) return 'never';
+    const s = Math.max(0, Math.floor((Date.now() - ts) / 1000));
+    return s < 60 ? `${s}s ago` : `${Math.floor(s / 60)}m ago`;
+  }
+
+  function clamp(n, min, max) {
+    return Math.max(min, Math.min(max, n));
+  }
+
+  function pushEvt(txt) {
+    ledger.unshift(`[${new Date().toLocaleTimeString()}] ${txt}`);
+    if (ledger.length > 32) ledger.length = 32;
+  }
+
+  function logEvt(kind, msg, extra) {
+    const suffix = extra ? ` | ${extra}` : '';
+    pushEvt(`${kind}: ${msg}${suffix}`);
+  }
+
+  function deriveState() {
+    const now = Date.now();
+    const signalStale = freshness.lastSignalTs ? (now - freshness.lastSignalTs > STALE_SIGNAL_MS) : true;
+    const healthStale = freshness.lastHealthTs ? (now - freshness.lastHealthTs > STALE_HEALTH_MS) : true;
+    const detectStale = freshness.lastDetectedTs ? (now - freshness.lastDetectedTs > QUIET_DETECT_MS) : true;
+
+    if (stale || healthStale) return ['IDLE/STALE', '🟠'];
+
+    if (signalStale) return ['NO SIGNAL', '🟠'];
+
+    if ((health.failed || 0) >= Math.max(3, (health.sent || 0))) return ['NOTIFY FAILING', '🔴'];
+
+    if ((health.detectorMisses || 0) >= 2) return ['DETECTOR MISS', '🟡'];
+
+    if (detectStale && (status.streamers || 0) > 0) return ['DETECTOR QUIET', '🟡'];
+
+    if ((health.fallback || 0) > 0 || (health.retried || 0) > 0) return ['DEGRADED', '🟡'];
+
+    if (status.followerThrottle || (status.streamers || 0) > 1) return ['THROTTLED', '🟠'];
+
+    return ['OK', '🟢'];
+  }
+
+  function baseStyle(el, obj) { Object.assign(el.style, obj); }
+
+  function buttonStyle(btn) {
+    baseStyle(btn, {
+      background: '#2a2a2a',
+      color: '#fff',
+      border: '1px solid #444',
+      borderRadius: '8px',
+      padding: '4px 8px',
+      cursor: 'pointer'
+    });
+  }
+
+  function ensureUI() {
+    if (pill && document.contains(pill)) return;
+
+    pill = mk('div');
+    baseStyle(pill, {
+      position: 'fixed',
+      right: '10px',
+      bottom: '10px',
+      zIndex: '2147483647',
+      background: 'rgba(18,18,18,.92)',
+      color: '#fff',
+      border: '1px solid #2f2f2f',
+      borderRadius: '12px',
+      padding: '8px 10px',
+      fontSize: '12px',
+      fontFamily: 'ui-sans-serif,system-ui',
+      display: 'flex',
+      gap: '8px',
+      alignItems: 'center',
+      boxShadow: '0 8px 20px rgba(0,0,0,.38)'
+    });
+
+    stateChip = mk('span');
+    stateChip.textContent = '🟢 OK';
+
+    gateBtn = mk('button');
+    allowBtn = mk('button');
+    togglePanelBtn = mk('button');
+    pauseBtn = mk('button');
+
+    gateBtn.textContent = '🚦 On';
+    allowBtn.textContent = 'Allow 10s';
+    togglePanelBtn.textContent = 'Panel';
+    pauseBtn.textContent = 'Pause UI';
+
+    for (const b of [gateBtn, allowBtn, togglePanelBtn, pauseBtn]) buttonStyle(b);
+
+    gateBtn.onclick = 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 {}
+      logEvt('gate', status.blockHistory ? 'on' : 'off');
+      render();
+    };
+
+    allowBtn.onclick = async () => {
+      const ms = 10000;
+      status.allowUntil = Date.now() + ms;
+      try { window.__chatTrafficGate?.allowForMs(ms); } catch {}
+      try { await api.runtime.sendMessage({ type: 'allowHistoryForMs', ms }); } catch {}
+      logEvt('gate', 'allow 10s');
+      render();
+    };
+
+    togglePanelBtn.onclick = () => {
+      ui.hiddenPanel = !ui.hiddenPanel;
+      panel.style.display = ui.hiddenPanel ? 'none' : 'block';
+      togglePanelBtn.textContent = ui.hiddenPanel ? 'Panel (off)' : 'Panel';
+    };
+
+    pauseBtn.onclick = () => {
+      ui.paused = !ui.paused;
+      pauseBtn.textContent = ui.paused ? 'Resume UI' : 'Pause UI';
+      logEvt('ui', ui.paused ? 'paused' : 'resumed');
+      render();
+    };
+
+    pill.append(stateChip, gateBtn, allowBtn, togglePanelBtn, pauseBtn);
+    document.documentElement.appendChild(pill);
+
+    panel = mk('div');
+    baseStyle(panel, {
+      position: 'fixed',
+      right: '10px',
+      bottom: '56px',
+      zIndex: '2147483647',
+      width: '390px',
+      maxHeight: '58vh',
+      overflow: 'auto',
+      background: 'rgba(10,10,10,.95)',
+      color: '#fff',
+      border: '1px solid #2d2d2d',
+      borderRadius: '12px',
+      padding: '10px',
+      fontSize: '12px',
+      fontFamily: 'ui-monospace,Consolas,monospace',
+      boxShadow: '0 10px 24px rgba(0,0,0,.45)'
+    });
+
+    const hdr = mk('div');
+    hdr.textContent = 'Traffic Gate Health';
+    baseStyle(hdr, {
+      fontWeight: '700',
+      marginBottom: '8px',
+      fontFamily: 'ui-sans-serif,system-ui'
+    });
+
+    statsBox = mk('pre');
+    eventsBox = mk('pre');
+    baseStyle(statsBox, { whiteSpace: 'pre-wrap', margin: '0 0 8px 0' });
+    baseStyle(eventsBox, { whiteSpace: 'pre-wrap', margin: '0' });
+
+    const row = mk('div');
+    baseStyle(row, { display: 'flex', gap: '8px', marginBottom: '8px', flexWrap: 'wrap' });
+
+    testBtn = mk('button');
+    refreshBtn = mk('button');
+    clearBtn = mk('button');
+
+    testBtn.textContent = 'Test notify';
+    refreshBtn.textContent = 'Refresh';
+    clearBtn.textContent = 'Clear events';
+
+    for (const b of [testBtn, refreshBtn, clearBtn]) buttonStyle(b);
+
+    testBtn.onclick = async () => {
+      const id = 'test_' + Date.now();
+      try {
+        const r = await api.runtime.sendMessage({
+          type: 'tgNotify',
+          eventId: id,
+          title: 'ChatGPT',
+          message: 'Manual test notify'
+        });
+        logEvt('notify', r && r.ok ? 'test ok' : 'test fail', id);
+      } catch {
+        logEvt('notify', 'test error');
+      }
+      await refreshHealth();
+      render();
+    };
+
+    refreshBtn.onclick = async () => {
+      await refreshHealth();
+      render();
+    };
+
+    clearBtn.onclick = () => {
+      ledger.length = 0;
+      logEvt('ui', 'events cleared');
+      render();
+    };
+
+    row.append(testBtn, refreshBtn, clearBtn);
+    panel.append(hdr, row, statsBox, eventsBox);
+    document.documentElement.appendChild(panel);
+  }
+
+  async function refreshHealth() {
+    try {
+      const r = await api.runtime.sendMessage({ type: 'tgNotifyHealth' });
+      freshness.lastHealthTs = Date.now();
+      stale = false;
+
+      if (r && r.stats) {
+        health.sent = Number(r.stats.sent || 0);
+        health.failed = Number(r.stats.failed || 0);
+        health.retried = Number(r.stats.retried || 0);
+        health.fallback = Number(r.stats.fallback || 0);
+        health.suppressed = Number(r.stats.suppressed || 0);
+        health.queueDepth = Number(r.queue || 0);
+        health.queueOldestAgeMs = Number(r.queueOldestAgeMs || health.queueOldestAgeMs || 0);
+        health.queueNewestAgeMs = Number(r.queueNewestAgeMs || health.queueNewestAgeMs || 0);
+        health.lastError = String(r.stats.lastError || health.lastError || '');
+        health.lastEventId = String(r.stats.lastEventId || health.lastEventId || '');
+        health.lastNotifyVia = String(r.stats.lastNotifyVia || health.lastNotifyVia || '');
+      }
+
+      // pull streamer budget directly from background snapshot (reliable even without recent perf events)
+      if (r?.orchestration?.budget) {
+        const b = r.orchestration.budget;
+        status.streamers = Number(b.totalStreamers || 0);
+        status.visibleStreamers = Number(b.visibleStreamers || 0);
+        status.followerThrottle = !!b.followerHold;
+      }
+
+      if (r?.orchestration?.health) {
+        const h = r.orchestration.health;
+        health.signals = Number(h.signals || 0);
+
+        // background schema uses detected_received / enqueued
+        health.detected = Number(h.detected_received || h.detected || 0);
+        health.enqueued = Number(h.enqueued || 0);
+
+        health.lastOkTs = Number(h.lastOkTs || 0);
+        health.detectorMisses = Number(h.detectorMisses || health.detectorMisses || 0);
+        health.lastSignalAgeMs = Number(h.lastSignalAgeMs || health.lastSignalAgeMs || 0);
+        health.lastDetectedAgeMs = Number(h.lastDetectedAgeMs || health.lastDetectedAgeMs || 0);
+        health.lastSeenFreshKind = String(h.lastSeenFreshKind || health.lastSeenFreshKind || '');
+
+        freshness.lastSignalTs = Number(h.lastSignalTs || freshness.lastSignalTs || 0);
+        freshness.lastDetectedTs = Number(h.lastDetectedTs || freshness.lastDetectedTs || 0);
+        freshness.lastStreamEndTs = Number(h.lastStreamEndTs || freshness.lastStreamEndTs || 0);
+      }
+
+      if (Array.isArray(r?.last)) {
+        for (const x of r.last.slice(-4)) {
+          const via = x?.via || 'evt';
+          const ok = x?.ok ? 'ok' : 'fail';
+          const eid = x?.eventId || '';
+          logEvt('last', `${via} ${ok}`, eid);
+        }
+      }
+    } catch {
+      stale = true;
+      logEvt('health', 'pull failed');
+    }
+  }
+
+  function render() {
+    ensureUI();
+    if (ui.paused) return;
+
+    const now = Date.now();
+    const inAllow = now < (status.allowUntil || 0);
+
+    freshness.heartbeatAgeMs = freshness.lastHeartbeatTs ? (now - freshness.lastHeartbeatTs) : 0;
+
+    gateBtn.textContent = status.blockHistory ? '🚦 On' : '🚦 Off';
+    allowBtn.textContent = inAllow ? `Allow ${Math.ceil((status.allowUntil - now) / 1000)}s` : 'Allow 10s';
+
+    const [txt, emoji] = deriveState();
+    stateChip.textContent = `${emoji} ${txt}`;
+    pill.title =
+      `profile:${status.profile} pressure:${Math.round(status.pressure || 0)} ` +
+      `streamers:${status.streamers || 0} visible:${status.visibleStreamers || 0} signals:${health.signals || 0} detected:${health.detected || 0}`;
+
+    statsBox.textContent =
+`role: ${status.role}
+profile: ${status.profile}
+pressure: ${Math.round(status.pressure || 0)}
+streamers(total/visible): ${status.streamers || 0}/${status.visibleStreamers || 0}
+followerThrottle: ${status.followerThrottle ? 'yes' : 'no'}
+
+notify sent/failed/retried: ${health.sent}/${health.failed}/${health.retried}
+fallback/suppressed: ${health.fallback}/${health.suppressed}
+queueDepth: ${health.queueDepth}
+queueOldestAgeMs: ${health.queueOldestAgeMs || 0}
+queueNewestAgeMs: ${health.queueNewestAgeMs || 0}
+lastNotifyVia: ${health.lastNotifyVia || '-'}
+lastEventId: ${health.lastEventId || '-'}
+
+signals/detected/enqueued: ${health.signals}/${health.detected}/${health.enqueued}
+detectorMisses: ${health.detectorMisses}
+lastFreshKind: ${health.lastSeenFreshKind || '-'}
+lastStreamEnd: ${ago(freshness.lastStreamEndTs)}
+lastSignal: ${ago(freshness.lastSignalTs)}
+lastDetected: ${ago(freshness.lastDetectedTs)}
+lastNotifyOk: ${ago(health.lastOkTs)}
+lastHealthPull: ${ago(freshness.lastHealthTs)}
+
+signalAgeMs(bg): ${health.lastSignalAgeMs || 0}
+detectedAgeMs(bg): ${health.lastDetectedAgeMs || 0}
+heartbeatAgeMs(local): ${freshness.heartbeatAgeMs || 0}
+lastError: ${health.lastError || '-'}`;
+
+    eventsBox.textContent = 'events:\n' + (ledger.length ? ledger.join('\n') : '(none)');
+  }
+
+  function bindEvents() {
+    window.addEventListener('tg:perf-profile', (ev) => {
+      const d = ev?.detail || {};
+      status.profile = d.profile || status.profile;
+      status.pressure = Number(d.pressure || status.pressure || 0);
+
+      // live profile events can carry budget hints
+      status.streamers = Number(d.totalStreamers || status.streamers || 0);
+      status.visibleStreamers = Number(d.visibleStreamers || status.visibleStreamers || 0);
+
+      status.role = d.role || status.role;
+      status.followerThrottle = !!d.followerThrottle;
+      freshness.lastSignalTs = Date.now();
+      logEvt('profile', `${status.profile} p=${Math.round(status.pressure || 0)} s=${status.streamers || 0}/${status.visibleStreamers || 0}`);
+      render();
+    }, { passive: true });
+
+    window.addEventListener('tg:reply-ready', (ev) => {
+      freshness.lastDetectedTs = Date.now();
+      health.detected = (health.detected || 0) + 1;
+      const d = ev?.detail || {};
+      logEvt('reply', `ready from ${d.tabId || 'tab'}`, `seq:${d.replySeq || '-'} id:${d.eventId || '-'}`);
+      render();
+    }, { passive: true });
+
+    // explicit freshness stream from autopilot
+    window.addEventListener('tg:signal-freshness', (ev) => {
+      const d = ev?.detail || {};
+      const kind = String(d.kind || 'tick');
+      health.lastSeenFreshKind = kind;
+
+      freshness.lastSignalTs = Number(d.ts || Date.now());
+      stale = false;
+
+      if (kind === 'heartbeat' || kind === 'heartbeat_forced') {
+        freshness.lastHeartbeatTs = Number(d.ts || Date.now());
+      }
+
+      if (kind === 'reply_detected') {
+        freshness.lastDetectedTs = Number(d.ts || Date.now());
+        health.detected = (health.detected || 0) + 1;
+        if (d.eventId) health.lastEventId = String(d.eventId);
+      }
+
+      if (kind === 'stream_transition' && d.streamEndTs) {
+        freshness.lastStreamEndTs = Number(d.streamEndTs || 0);
+        health.lastStreamEndTs = freshness.lastStreamEndTs;
+      }
+
+      if (kind === 'detector_miss') {
+        health.detectorMisses = Math.max(health.detectorMisses || 0, Number(d.detectorMisses || 0));
+      }
+
+      if (kind !== 'heartbeat') {
+        const compact = `k=${kind} p=${Math.round(Number(d.pressure || status.pressure || 0))} vis=${d.visible ? 1 : 0}`;
+        logEvt('fresh', compact);
+      }
+
+      render();
+    }, { passive: true });
+  }
+
+  function startStaleWatchdog() {
+    setInterval(() => {
+      const now = Date.now();
+      const healthTooOld = freshness.lastHealthTs && (now - freshness.lastHealthTs > STALE_HEALTH_MS);
+      const signalTooOld = freshness.lastSignalTs && (now - freshness.lastSignalTs > STALE_SIGNAL_MS);
+      stale = !!(healthTooOld || signalTooOld);
+    }, 2000);
+  }
+
+  async function init() {
+    ensureUI();
+    bindEvents();
+    startStaleWatchdog();
+
+    try {
+      const resp = await api.runtime.sendMessage({ type: 'requestStatus' });
+      if (resp) {
+        status.blockHistory = !!resp.blockHistory;
+        status.allowUntil = Number(resp.allowUntil || 0);
+        status.role = resp.role || status.role;
+      }
+    } catch {}
+
+    await refreshHealth();
+    render();
+
+    // health pull loop
+    setInterval(async () => {
+      await refreshHealth();
+      render();
+    }, 5000);
+
+    // ui countdown / age loop
+    setInterval(render, 1000);
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', init, { once: true });
+  } else {
+    init();
+  }
+})();

GPTTrafficgateUPDATEDv3.1/manifest.json

@@ -0,0 +1,59 @@
+{
+  "manifest_version": 2,
+  "name": "Chat Traffic Gate (ChatGPT) — AutoPilot v3.1 (Orchestrated Diagnostics)",
+  "version": "1.3.0",
+  "description": "Network history gate + cross-tab orchestrator + observable notification health panel.",
+  "author": "local",
+  "homepage_url": "https://chatgpt.com/",
+  "permissions": [
+    "storage",
+    "webRequest",
+    "alarms",
+    "tabs",
+    "notifications",
+    "https://chat.openai.com/*",
+    "https://chatgpt.com/*"
+  ],
+  "background": {
+    "scripts": [
+      "background.js"
+    ],
+    "persistent": false
+  },
+  "content_scripts": [
+    {
+      "matches": [
+        "https://chat.openai.com/*",
+        "https://chatgpt.com/*"
+      ],
+      "js": [
+        "content/core-utils.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/core-utils.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"
+    }
+  }
+}