@shawnowen/comet-mcp 2.3.0

package/extension/background.js

@@ -0,0 +1,1094 @@
+// Comet Tab Groups Bridge — service worker
+// Marker for CDP discovery: comet-mcp scans service workers for this flag
+self.__COMET_TAB_GROUPS_BRIDGE__ = true;
+self.__COMET_TAB_GROUPS_VERSION__ = "1.4.0";
+
+// ─── Robust MV3 Keepalive ────────────────────────────────────────────────────
+//
+// MV3 service workers are killed after ~30s of idle. setInterval does NOT
+// prevent this — it's just a JS timer, not "pending work" in Chromium's eyes.
+//
+// Strategy (triple-layered):
+//   1. Self-port: chrome.runtime.connect() to self keeps worker alive.
+//      Chromium won't kill a worker with an active Port. Ports auto-disconnect
+//      after ~5 minutes; onDisconnect immediately reconnects.
+//   2. chrome.alarms: fires every 25s as a safety net. If the worker was
+//      somehow killed, the alarm event restarts it.
+//   3. onMessage: responds to external pings (CDP health checks, MCP server).
+
+let keepAlivePort = null;
+
+function connectKeepAlive() {
+  try {
+    keepAlivePort = chrome.runtime.connect({ name: 'keepalive' });
+    keepAlivePort.onDisconnect.addListener(() => {
+      // Reading lastError clears it and prevents the "Unchecked runtime.lastError" warning
+      void chrome.runtime.lastError;
+      keepAlivePort = null;
+      // Small delay to avoid tight reconnect loop on extension unload/reload
+      setTimeout(connectKeepAlive, 250);
+    });
+  } catch {
+    keepAlivePort = null;
+    // Extension context may be invalidated; retry via alarm
+  }
+}
+
+chrome.runtime.onConnect.addListener((port) => {
+  if (port.name === 'keepalive') {
+    // Accept the self-connection — its mere existence keeps us alive
+    return;
+  }
+});
+
+// Start self-port keepalive after a brief delay so onConnect listener registers first
+setTimeout(connectKeepAlive, 50);
+
+// Alarm fallback — restarts worker if self-port somehow fails
+chrome.alarms.create('keepalive', { periodInMinutes: 0.4167 }); // clamped to 30s minimum
+
+chrome.alarms.onAlarm.addListener((alarm) => {
+  if (alarm.name === 'keepalive') {
+    // Real async chrome API call extends worker lifetime
+    chrome.tabs.query({ active: true, currentWindow: true }).catch(() => { });
+    // Ensure self-port is still connected
+    if (!keepAlivePort) connectKeepAlive();
+  }
+});
+
+// ─── Sidebar Message Dispatcher (T004) ────────────────────────────────────────
+//
+// All sidebar ↔ background communication follows the contract:
+//   Request:  { type: string, payload?: object }
+//   Response: { ok: boolean, data?: any, error?: string }
+//
+// Message handlers are registered in the `messageHandlers` map below.
+// Each handler is an async function: (payload) => data
+
+const messageHandlers = {};
+
+function registerHandler(type, handler) {
+  messageHandlers[type] = handler;
+}
+
+// Central dispatcher — routes messages to registered handlers
+chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
+  // Legacy ping support (for CDP health checks)
+  if (msg?.type === 'ping') {
+    sendResponse({ pong: true, ts: Date.now(), version: self.__COMET_TAB_GROUPS_VERSION__ });
+    return true;
+  }
+
+  const handler = messageHandlers[msg?.type];
+  if (!handler) {
+    // Unknown message type — ignore silently
+    return false;
+  }
+
+  // Execute handler asynchronously, respond with contract format
+  (async () => {
+    try {
+      const data = await handler(msg.payload || {});
+      sendResponse({ ok: true, data });
+    } catch (err) {
+      console.error(`[Comet] Handler error for "${msg.type}":`, err);
+      sendResponse({ ok: false, error: err.message || String(err) });
+    }
+  })();
+
+  return true; // keep sendResponse channel open for async
+});
+
+// Respond to messages from external extensions or CDP-injected scripts
+chrome.runtime.onMessageExternal.addListener((msg, sender, sendResponse) => {
+  if (msg?.type === 'ping') {
+    sendResponse({ pong: true, ts: Date.now(), version: self.__COMET_TAB_GROUPS_VERSION__ });
+    return true;
+  }
+});
+
+// ─── Message Handlers ─────────────────────────────────────────────────────────
+
+// T005: getGroups — returns all live tab groups
+registerHandler('getGroups', async () => {
+  const groups = await chrome.tabGroups.query({});
+  return groups.map(g => ({
+    id: g.id,
+    title: g.title || '',
+    color: g.color,
+    collapsed: g.collapsed,
+    windowId: g.windowId,
+  }));
+});
+
+// T006: getTabs — returns all tabs with group/window info
+registerHandler('getTabs', async () => {
+  const tabs = await chrome.tabs.query({});
+  return tabs.map(t => ({
+    id: t.id,
+    groupId: t.groupId,
+    windowId: t.windowId,
+    index: t.index,
+    title: t.title || '',
+    url: t.url || '',
+    active: t.active,
+    favIconUrl: t.favIconUrl || '',
+  }));
+});
+
+// T007: healthCheck — checks CDP bridge presence and returns version
+registerHandler('healthCheck', async () => {
+  // The bridge is running if we're here (service worker is alive)
+  // Check if CDP connection is available by testing if we can query tabs
+  let cdpConnected = false;
+  try {
+    await chrome.tabs.query({ active: true, currentWindow: true });
+    cdpConnected = true;
+  } catch {
+    cdpConnected = false;
+  }
+  return {
+    cdpConnected,
+    version: self.__COMET_TAB_GROUPS_VERSION__,
+    uptime: Date.now(),
+  };
+});
+
+// ─── Archive Storage Helpers ──────────────────────────────────────────────────
+
+const ARCHIVE_KEY = 'archivedGroups';
+
+async function loadArchive() {
+  const result = await chrome.storage.local.get(ARCHIVE_KEY);
+  return result[ARCHIVE_KEY] || [];
+}
+
+async function saveArchive(entries) {
+  await chrome.storage.local.set({ [ARCHIVE_KEY]: entries });
+}
+
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+
+// T013: getArchivedGroups — returns all archived groups from storage
+registerHandler('getArchivedGroups', async () => {
+  return await loadArchive();
+});
+
+// T014: archiveGroup — save tabs from a live group, then close them
+registerHandler('archiveGroup', async ({ groupId, title }) => {
+  // Get all tabs in this group
+  const tabs = await chrome.tabs.query({ groupId });
+  if (!tabs.length) throw new Error(`No tabs found in group ${groupId}`);
+
+  // Get group info for color
+  const groups = await chrome.tabGroups.query({});
+  const group = groups.find(g => g.id === groupId);
+  const color = group ? group.color : 'grey';
+
+  // Create archive entry
+  const entry = {
+    taskThreadId: generateId(),
+    title: title || group?.title || 'Untitled',
+    color,
+    collapsed: group?.collapsed || false,
+    urls: tabs.map(t => ({ url: t.url || '', title: t.title || '' })),
+    archivedAt: new Date().toISOString(),
+    restoredAt: null,
+    status: 'archived',
+  };
+
+  // Save to archive
+  const archive = await loadArchive();
+  archive.unshift(entry); // newest first
+  await saveArchive(archive);
+
+  // Close the tabs
+  const tabIds = tabs.map(t => t.id);
+  await chrome.tabs.remove(tabIds);
+
+  pushEvent('archive.created', { taskThreadId: entry.taskThreadId, title: entry.title, tabCount: tabs.length });
+  return { taskThreadId: entry.taskThreadId };
+});
+
+// T015: restoreGroup — reopen all tabs from an archive entry
+registerHandler('restoreGroup', async ({ taskThreadId }) => {
+  const archive = await loadArchive();
+  const idx = archive.findIndex(e => e.taskThreadId === taskThreadId);
+  if (idx === -1) throw new Error(`Archive entry not found: ${taskThreadId}`);
+
+  const entry = archive[idx];
+  const urls = entry.urls || [];
+  if (!urls.length) throw new Error('Archive entry has no URLs');
+
+  // Open tabs
+  const tabPromises = urls.map(u => chrome.tabs.create({ url: u.url, active: false }));
+  const tabs = await Promise.all(tabPromises);
+
+  // Group the tabs
+  const tabIds = tabs.map(t => t.id);
+  const groupId = await chrome.tabs.group({ tabIds });
+
+  // Set group properties
+  await chrome.tabGroups.update(groupId, {
+    title: entry.title || 'Restored',
+    color: entry.color || 'grey',
+    collapsed: false,
+  });
+
+  // Update archive entry status
+  archive[idx] = {
+    ...entry,
+    status: 'saved',
+    restoredAt: new Date().toISOString(),
+  };
+  await saveArchive(archive);
+
+  pushEvent('archive.restored', { taskThreadId, title: entry.title, tabCount: urls.length, groupId });
+  return { groupId };
+});
+
+// T016: deleteArchived — remove an archive entry
+registerHandler('deleteArchived', async ({ taskThreadId }) => {
+  const archive = await loadArchive();
+  const filtered = archive.filter(e => e.taskThreadId !== taskThreadId);
+  const deleted = filtered.length < archive.length;
+  await saveArchive(filtered);
+
+  if (deleted) {
+    pushEvent('archive.deleted', { taskThreadId });
+  }
+  return { deleted };
+});
+
+// ─── OneTab Parity Handlers ──────────────────────────────────────────────────
+
+// saveAllTabs — archive ALL open tab groups in one click (like OneTab's "Store all")
+registerHandler('saveAllTabs', async () => {
+  const groups = await chrome.tabGroups.query({});
+  const allTabs = await chrome.tabs.query({});
+
+  if (!groups.length && !allTabs.length) {
+    return { archived: 0, totalTabs: 0 };
+  }
+
+  const archive = await loadArchive();
+  let archivedCount = 0;
+  let totalTabs = 0;
+  const tabIdsToClose = [];
+
+  // Archive each tab group
+  for (const group of groups) {
+    const groupTabs = allTabs.filter(t => t.groupId === group.id);
+    if (!groupTabs.length) continue;
+
+    const entry = {
+      taskThreadId: generateId(),
+      title: group.title || 'Untitled',
+      color: group.color || 'grey',
+      collapsed: false,
+      urls: groupTabs.map(t => ({ url: t.url || '', title: t.title || '' })),
+      archivedAt: new Date().toISOString(),
+      restoredAt: null,
+      status: 'archived',
+    };
+    archive.unshift(entry);
+    archivedCount++;
+    totalTabs += groupTabs.length;
+    tabIdsToClose.push(...groupTabs.map(t => t.id));
+  }
+
+  // Archive ungrouped tabs as a separate group
+  const ungroupedTabs = allTabs.filter(t => t.groupId === -1 && !t.pinned);
+  if (ungroupedTabs.length > 0) {
+    const entry = {
+      taskThreadId: generateId(),
+      title: 'Ungrouped Tabs',
+      color: 'grey',
+      collapsed: false,
+      urls: ungroupedTabs.map(t => ({ url: t.url || '', title: t.title || '' })),
+      archivedAt: new Date().toISOString(),
+      restoredAt: null,
+      status: 'archived',
+    };
+    archive.unshift(entry);
+    archivedCount++;
+    totalTabs += ungroupedTabs.length;
+    tabIdsToClose.push(...ungroupedTabs.map(t => t.id));
+  }
+
+  await saveArchive(archive);
+
+  // Close all archived tabs (but keep at least one tab open to prevent browser from closing)
+  if (tabIdsToClose.length > 0) {
+    // Create a blank tab first so the browser doesn't close
+    await chrome.tabs.create({ url: 'chrome://newtab', active: true });
+    await chrome.tabs.remove(tabIdsToClose);
+  }
+
+  pushEvent('archive.savedAll', { groupCount: archivedCount, tabCount: totalTabs });
+  return { archived: archivedCount, totalTabs };
+});
+
+// restoreSingleTab — open a single URL from an archived group
+registerHandler('restoreSingleTab', async ({ taskThreadId, url }) => {
+  if (!url) throw new Error('URL is required');
+  const tab = await chrome.tabs.create({ url, active: true });
+  return { tabId: tab.id };
+});
+
+// renameArchived — rename an archived group's title
+registerHandler('renameArchived', async ({ taskThreadId, newTitle }) => {
+  if (!taskThreadId) throw new Error('taskThreadId is required');
+  if (!newTitle || !newTitle.trim()) throw new Error('New title is required');
+
+  const archive = await loadArchive();
+  const entry = archive.find(e => e.taskThreadId === taskThreadId);
+  if (!entry) throw new Error(`Archive entry not found: ${taskThreadId}`);
+
+  entry.title = newTitle.trim();
+  await saveArchive(archive);
+
+  pushEvent('archive.renamed', { taskThreadId, newTitle: entry.title });
+  return { renamed: true, title: entry.title };
+});
+
+// T020: getRecentlyClosed — returns recently closed tabs/windows
+registerHandler('getRecentlyClosed', async ({ maxResults = 25 } = {}) => {
+  const sessions = await chrome.sessions.getRecentlyClosed({ maxResults });
+  return sessions.map(s => ({
+    sessionId: s.tab?.sessionId || s.window?.sessionId || '',
+    lastModified: s.lastModified,
+    tab: s.tab ? {
+      title: s.tab.title || '',
+      url: s.tab.url || '',
+      favIconUrl: s.tab.favIconUrl || '',
+    } : null,
+    window: s.window ? {
+      tabs: (s.window.tabs || []).map(t => ({
+        title: t.title || '',
+        url: t.url || '',
+        favIconUrl: t.favIconUrl || '',
+      })),
+    } : null,
+  }));
+});
+
+// T021: restoreClosed — restore a recently closed tab or window
+registerHandler('restoreClosed', async ({ sessionId }) => {
+  await chrome.sessions.restore(sessionId);
+  return {};
+});
+
+// T028: importUrls — import URL groups to archive
+registerHandler('importUrls', async ({ groups }) => {
+  if (!groups || !groups.length) throw new Error('No groups to import');
+
+  const archive = await loadArchive();
+  let imported = 0;
+
+  for (const group of groups) {
+    const entry = {
+      taskThreadId: generateId(),
+      title: group.name || 'Imported',
+      color: 'grey',
+      collapsed: false,
+      urls: (group.urls || []).map(u => ({ url: u.url || '', title: u.title || '' })),
+      archivedAt: new Date().toISOString(),
+      restoredAt: null,
+      status: 'archived',
+    };
+    archive.unshift(entry);
+    imported += entry.urls.length;
+  }
+
+  await saveArchive(archive);
+  pushEvent('archive.imported', { groupCount: groups.length, urlCount: imported });
+  return { imported };
+});
+
+// T032: focusTab — switch browser focus to a specific tab
+registerHandler('focusTab', async ({ tabId, windowId }) => {
+  await chrome.tabs.update(tabId, { active: true });
+  if (windowId) {
+    await chrome.windows.update(windowId, { focused: true });
+  }
+  return {};
+});
+
+// T033: closeTab — close a single tab
+registerHandler('closeTab', async ({ tabId }) => {
+  await chrome.tabs.remove(tabId);
+  return {};
+});
+
+// T034: closeGroup — close all tabs in a group
+registerHandler('closeGroup', async ({ groupId }) => {
+  const tabs = await chrome.tabs.query({ groupId });
+  if (tabs.length) {
+    await chrome.tabs.remove(tabs.map(t => t.id));
+  }
+  return {};
+});
+
+// T036: exportAll — export all live and archived session data
+registerHandler('exportAll', async () => {
+  const [groups, tabs, archived] = await Promise.all([
+    chrome.tabGroups.query({}),
+    chrome.tabs.query({}),
+    loadArchive(),
+  ]);
+
+  return {
+    exportedAt: new Date().toISOString(),
+    version: self.__COMET_TAB_GROUPS_VERSION__,
+    live: {
+      groups: groups.map(g => ({
+        id: g.id, title: g.title || '', color: g.color,
+        collapsed: g.collapsed, windowId: g.windowId,
+        tabs: tabs.filter(t => t.groupId === g.id).map(t => ({
+          title: t.title || '', url: t.url || '',
+        })),
+      })),
+    },
+    archived,
+  };
+});
+
+// T017: One-time archive import from JSON file on install/startup
+// Resolves archive path via $COMET_DATA_DIR env variable (fallback: ~/.equabot)
+// and imports entries into chrome.storage.local, avoiding duplicates by taskThreadId.
+async function importArchiveFromJsonFile() {
+  try {
+    const existing = await loadArchive();
+    if (existing.length > 0) {
+      console.log('[Comet] Archive already has data, skipping file import.');
+      return; // Already has data, skip import
+    }
+
+    // Check if we've already attempted import
+    const flags = await chrome.storage.local.get('archiveImportAttempted');
+    if (flags.archiveImportAttempted) return;
+    await chrome.storage.local.set({ archiveImportAttempted: true });
+
+    // Attempt to read archive file paths
+    // In Chrome extensions, direct file:// access requires the "file" permission
+    // which isn't available in MV3 side panel context. The recommended path is:
+    // 1. Pre-import via CLI: node scripts/onetab-import.mjs --input <file>
+    // 2. Or use the sidebar Import UI to paste URLs directly
+    //
+    // We still attempt a fetch as a best-effort approach:
+    const archivePaths = [
+      'file://' + (globalThis.__COMET_DATA_DIR || '') + '/browser/tab-groups-archive.json',
+    ];
+
+    for (const path of archivePaths) {
+      if (!path || path === 'file:///browser/tab-groups-archive.json') continue;
+      try {
+        const resp = await fetch(path);
+        if (resp.ok) {
+          const data = await resp.json();
+          if (Array.isArray(data) && data.length > 0) {
+            // Merge entries, avoiding duplicates
+            const ids = new Set(existing.map(e => e.taskThreadId));
+            const newEntries = data.filter(e => e.taskThreadId && !ids.has(e.taskThreadId));
+            if (newEntries.length > 0) {
+              await saveArchive([...newEntries, ...existing]);
+              pushEvent('archive.fileImported', { count: newEntries.length });
+              console.log(`[Comet] Imported ${newEntries.length} entries from archive file.`);
+            }
+            return;
+          }
+        }
+      } catch {
+        // fetch failed for this path, try next
+      }
+    }
+
+    console.log('[Comet] Archive file import: no file accessible. Use CLI or UI import instead.');
+  } catch (err) {
+    console.log('[Comet] Archive file import skipped:', err.message);
+  }
+}
+
+chrome.runtime.onInstalled.addListener(() => {
+  chrome.alarms.create('keepalive', { periodInMinutes: 0.4167 });
+  if (!keepAlivePort) connectKeepAlive();
+  // Attempt one-time archive import
+  importArchiveFromJsonFile();
+  // Create context menus
+  createContextMenus();
+});
+
+// ─── Domain Exclusion Storage ─────────────────────────────────────────────────
+
+const EXCLUSIONS_KEY = 'excludedDomains';
+
+async function loadExclusions() {
+  const result = await chrome.storage.local.get(EXCLUSIONS_KEY);
+  return result[EXCLUSIONS_KEY] || [];
+}
+
+async function saveExclusions(domains) {
+  await chrome.storage.local.set({ [EXCLUSIONS_KEY]: domains });
+}
+
+function getDomain(url) {
+  try {
+    return new URL(url).hostname.replace(/^www\./, '');
+  } catch {
+    return '';
+  }
+}
+
+function isExcluded(url, exclusions) {
+  const domain = getDomain(url);
+  return exclusions.some(d => domain === d || domain.endsWith('.' + d));
+}
+
+// Message handlers for exclusions
+registerHandler('getExclusions', async () => {
+  return await loadExclusions();
+});
+
+registerHandler('addExclusion', async ({ domain }) => {
+  if (!domain) throw new Error('Domain required');
+  const exclusions = await loadExclusions();
+  const clean = domain.replace(/^www\./, '').toLowerCase();
+  if (!exclusions.includes(clean)) {
+    exclusions.push(clean);
+    await saveExclusions(exclusions);
+    // Update context menu to reflect current tab's domain
+    pushEvent('exclusion.added', { domain: clean });
+  }
+  return { exclusions };
+});
+
+registerHandler('removeExclusion', async ({ domain }) => {
+  if (!domain) throw new Error('Domain required');
+  const exclusions = await loadExclusions();
+  const clean = domain.replace(/^www\./, '').toLowerCase();
+  const filtered = exclusions.filter(d => d !== clean);
+  await saveExclusions(filtered);
+  pushEvent('exclusion.removed', { domain: clean });
+  return { exclusions: filtered };
+});
+
+// ─── Context Menu System ──────────────────────────────────────────────────────
+
+function createContextMenus() {
+  // Remove existing menus first (in case of update)
+  chrome.contextMenus.removeAll(() => {
+    // Parent menu
+    chrome.contextMenus.create({
+      id: 'comet-parent',
+      title: 'Comet Session Manager',
+      contexts: ['all'],
+    });
+
+    // Open side panel
+    chrome.contextMenus.create({
+      id: 'comet-open-sidebar',
+      parentId: 'comet-parent',
+      title: 'Open Comet Sidebar',
+      contexts: ['all'],
+    });
+
+    chrome.contextMenus.create({
+      id: 'comet-sep-1',
+      parentId: 'comet-parent',
+      type: 'separator',
+      contexts: ['all'],
+    });
+
+    // Send this tab
+    chrome.contextMenus.create({
+      id: 'comet-send-tab',
+      parentId: 'comet-parent',
+      title: 'Send this tab to Comet',
+      contexts: ['all'],
+    });
+
+    // Send all tabs in this window
+    chrome.contextMenus.create({
+      id: 'comet-send-window',
+      parentId: 'comet-parent',
+      title: 'Send all tabs in this window to Comet',
+      contexts: ['all'],
+    });
+
+    // Send tabs in this tab group
+    chrome.contextMenus.create({
+      id: 'comet-send-group',
+      parentId: 'comet-parent',
+      title: 'Send all tabs in this tab group to Comet',
+      contexts: ['all'],
+    });
+
+    // Send selected tabs
+    chrome.contextMenus.create({
+      id: 'comet-send-selected',
+      parentId: 'comet-parent',
+      title: 'Send selected tabs to Comet',
+      contexts: ['all'],
+    });
+
+    chrome.contextMenus.create({
+      id: 'comet-sep-2',
+      parentId: 'comet-parent',
+      type: 'separator',
+      contexts: ['all'],
+    });
+
+    // Send all except this tab
+    chrome.contextMenus.create({
+      id: 'comet-send-except',
+      parentId: 'comet-parent',
+      title: 'Send all tabs except this tab to Comet',
+      contexts: ['all'],
+    });
+
+    // Send tabs to the left
+    chrome.contextMenus.create({
+      id: 'comet-send-left',
+      parentId: 'comet-parent',
+      title: 'Send tabs on the left to Comet',
+      contexts: ['all'],
+    });
+
+    // Send tabs to the right
+    chrome.contextMenus.create({
+      id: 'comet-send-right',
+      parentId: 'comet-parent',
+      title: 'Send tabs on the right to Comet',
+      contexts: ['all'],
+    });
+
+    chrome.contextMenus.create({
+      id: 'comet-sep-3',
+      parentId: 'comet-parent',
+      type: 'separator',
+      contexts: ['all'],
+    });
+
+    // Send all from all windows
+    chrome.contextMenus.create({
+      id: 'comet-send-all',
+      parentId: 'comet-parent',
+      title: 'Send all tabs from all windows to Comet',
+      contexts: ['all'],
+    });
+
+    chrome.contextMenus.create({
+      id: 'comet-sep-4',
+      parentId: 'comet-parent',
+      type: 'separator',
+      contexts: ['all'],
+    });
+
+    // Exclude domain (dynamic — updated on tab change)
+    chrome.contextMenus.create({
+      id: 'comet-exclude-domain',
+      parentId: 'comet-parent',
+      title: 'Exclude this domain from Comet',
+      contexts: ['all'],
+    });
+
+    console.log('[Comet] Context menus created.');
+  });
+}
+
+// Update the "Exclude" menu item to show the current domain
+chrome.tabs.onActivated.addListener(async ({ tabId }) => {
+  try {
+    const tab = await chrome.tabs.get(tabId);
+    if (tab.url) {
+      const domain = getDomain(tab.url);
+      const exclusions = await loadExclusions();
+      const isCurrentlyExcluded = exclusions.some(d => domain === d || domain.endsWith('.' + d));
+      chrome.contextMenus.update('comet-exclude-domain', {
+        title: isCurrentlyExcluded
+          ? `Include ${domain} in Comet (currently excluded)`
+          : `Exclude ${domain} from Comet`,
+      });
+    }
+  } catch {
+    // Tab may not exist, ignore
+  }
+});
+
+// ─── Context Menu Click Handler ───────────────────────────────────────────────
+
+chrome.contextMenus.onClicked.addListener(async (info, tab) => {
+  try {
+    switch (info.menuItemId) {
+
+      case 'comet-open-sidebar': {
+        // Open the side panel for this window
+        if (tab?.windowId) {
+          await chrome.sidePanel.open({ windowId: tab.windowId });
+        }
+        break;
+      }
+
+      case 'comet-send-tab': {
+        // Archive just this one tab
+        if (!tab) break;
+        const exclusions = await loadExclusions();
+        if (isExcluded(tab.url, exclusions)) {
+          console.log(`[Comet] Skipped excluded domain: ${getDomain(tab.url)}`);
+          break;
+        }
+        const entry = {
+          taskThreadId: generateId(),
+          title: tab.title || 'Single Tab',
+          color: 'grey',
+          collapsed: false,
+          urls: [{ url: tab.url || '', title: tab.title || '' }],
+          archivedAt: new Date().toISOString(),
+          restoredAt: null,
+          status: 'archived',
+        };
+        // If tab is in a group, use the group name
+        if (tab.groupId && tab.groupId !== -1) {
+          try {
+            const group = await chrome.tabGroups.get(tab.groupId);
+            entry.title = group.title || entry.title;
+            entry.color = group.color || 'grey';
+          } catch { /* group may not exist */ }
+        }
+        const archive = await loadArchive();
+        archive.unshift(entry);
+        await saveArchive(archive);
+        await chrome.tabs.remove(tab.id);
+        pushEvent('context.sendTab', { title: entry.title, url: tab.url });
+        break;
+      }
+
+      case 'comet-send-window': {
+        // Archive all tabs in the current window
+        if (!tab) break;
+        const windowTabs = await chrome.tabs.query({ windowId: tab.windowId });
+        const exclusions = await loadExclusions();
+        const eligible = windowTabs.filter(t => !t.pinned && !isExcluded(t.url, exclusions));
+        if (!eligible.length) break;
+
+        // Group tabs by their tab group
+        const grouped = new Map(); // groupId → tabs[]
+        for (const t of eligible) {
+          const key = t.groupId > 0 ? t.groupId : -1;
+          if (!grouped.has(key)) grouped.set(key, []);
+          grouped.get(key).push(t);
+        }
+
+        const archive = await loadArchive();
+        const groups = await chrome.tabGroups.query({ windowId: tab.windowId });
+        const groupMap = new Map(groups.map(g => [g.id, g]));
+
+        for (const [groupId, tabs] of grouped) {
+          const group = groupMap.get(groupId);
+          const entry = {
+            taskThreadId: generateId(),
+            title: group?.title || (groupId === -1 ? 'Ungrouped Tabs' : 'Untitled'),
+            color: group?.color || 'grey',
+            collapsed: false,
+            urls: tabs.map(t => ({ url: t.url || '', title: t.title || '' })),
+            archivedAt: new Date().toISOString(),
+            restoredAt: null,
+            status: 'archived',
+          };
+          archive.unshift(entry);
+        }
+
+        await saveArchive(archive);
+        // Create a blank tab before closing so window doesn't close
+        await chrome.tabs.create({ windowId: tab.windowId, url: 'chrome://newtab', active: true });
+        await chrome.tabs.remove(eligible.map(t => t.id));
+        pushEvent('context.sendWindow', { windowId: tab.windowId, tabCount: eligible.length });
+        break;
+      }
+
+      case 'comet-send-group': {
+        // Archive this tab's group
+        if (!tab || !tab.groupId || tab.groupId === -1) break;
+        const groupTabs = await chrome.tabs.query({ groupId: tab.groupId });
+        const exclusions = await loadExclusions();
+        const eligible = groupTabs.filter(t => !isExcluded(t.url, exclusions));
+        if (!eligible.length) break;
+
+        let groupTitle = 'Untitled';
+        let groupColor = 'grey';
+        try {
+          const group = await chrome.tabGroups.get(tab.groupId);
+          groupTitle = group.title || 'Untitled';
+          groupColor = group.color || 'grey';
+        } catch { /* ignore */ }
+
+        const entry = {
+          taskThreadId: generateId(),
+          title: groupTitle,
+          color: groupColor,
+          collapsed: false,
+          urls: eligible.map(t => ({ url: t.url || '', title: t.title || '' })),
+          archivedAt: new Date().toISOString(),
+          restoredAt: null,
+          status: 'archived',
+        };
+
+        const archive = await loadArchive();
+        archive.unshift(entry);
+        await saveArchive(archive);
+        await chrome.tabs.remove(eligible.map(t => t.id));
+        pushEvent('context.sendGroup', { title: groupTitle, tabCount: eligible.length });
+        break;
+      }
+
+      case 'comet-send-selected': {
+        // Archive highlighted (selected) tabs
+        if (!tab) break;
+        const highlighted = await chrome.tabs.query({ windowId: tab.windowId, highlighted: true });
+        const exclusions = await loadExclusions();
+        const eligible = highlighted.filter(t => !t.pinned && !isExcluded(t.url, exclusions));
+        if (!eligible.length) break;
+
+        const entry = {
+          taskThreadId: generateId(),
+          title: `Selected Tabs (${eligible.length})`,
+          color: 'grey',
+          collapsed: false,
+          urls: eligible.map(t => ({ url: t.url || '', title: t.title || '' })),
+          archivedAt: new Date().toISOString(),
+          restoredAt: null,
+          status: 'archived',
+        };
+
+        const archive = await loadArchive();
+        archive.unshift(entry);
+        await saveArchive(archive);
+        // Keep at least one tab open
+        const remaining = await chrome.tabs.query({ windowId: tab.windowId });
+        if (remaining.length <= eligible.length) {
+          await chrome.tabs.create({ windowId: tab.windowId, url: 'chrome://newtab', active: true });
+        }
+        await chrome.tabs.remove(eligible.map(t => t.id));
+        pushEvent('context.sendSelected', { tabCount: eligible.length });
+        break;
+      }
+
+      case 'comet-send-except': {
+        // Archive all tabs in window except this one
+        if (!tab) break;
+        const allInWindow = await chrome.tabs.query({ windowId: tab.windowId });
+        const exclusions = await loadExclusions();
+        const toArchive = allInWindow.filter(t => t.id !== tab.id && !t.pinned && !isExcluded(t.url, exclusions));
+        if (!toArchive.length) break;
+
+        const entry = {
+          taskThreadId: generateId(),
+          title: `All except: ${tab.title || 'current tab'}`,
+          color: 'grey',
+          collapsed: false,
+          urls: toArchive.map(t => ({ url: t.url || '', title: t.title || '' })),
+          archivedAt: new Date().toISOString(),
+          restoredAt: null,
+          status: 'archived',
+        };
+
+        const archive = await loadArchive();
+        archive.unshift(entry);
+        await saveArchive(archive);
+        await chrome.tabs.remove(toArchive.map(t => t.id));
+        pushEvent('context.sendExcept', { keptTab: tab.title, archivedCount: toArchive.length });
+        break;
+      }
+
+      case 'comet-send-left': {
+        // Archive tabs to the left of current tab
+        if (!tab) break;
+        const allInWindow = await chrome.tabs.query({ windowId: tab.windowId });
+        const exclusions = await loadExclusions();
+        const toArchive = allInWindow.filter(t => t.index < tab.index && !t.pinned && !isExcluded(t.url, exclusions));
+        if (!toArchive.length) break;
+
+        const entry = {
+          taskThreadId: generateId(),
+          title: `Tabs left of: ${tab.title || 'current'}`,
+          color: 'grey',
+          collapsed: false,
+          urls: toArchive.map(t => ({ url: t.url || '', title: t.title || '' })),
+          archivedAt: new Date().toISOString(),
+          restoredAt: null,
+          status: 'archived',
+        };
+
+        const archive = await loadArchive();
+        archive.unshift(entry);
+        await saveArchive(archive);
+        await chrome.tabs.remove(toArchive.map(t => t.id));
+        pushEvent('context.sendLeft', { count: toArchive.length });
+        break;
+      }
+
+      case 'comet-send-right': {
+        // Archive tabs to the right of current tab
+        if (!tab) break;
+        const allInWindow = await chrome.tabs.query({ windowId: tab.windowId });
+        const exclusions = await loadExclusions();
+        const toArchive = allInWindow.filter(t => t.index > tab.index && !t.pinned && !isExcluded(t.url, exclusions));
+        if (!toArchive.length) break;
+
+        const entry = {
+          taskThreadId: generateId(),
+          title: `Tabs right of: ${tab.title || 'current'}`,
+          color: 'grey',
+          collapsed: false,
+          urls: toArchive.map(t => ({ url: t.url || '', title: t.title || '' })),
+          archivedAt: new Date().toISOString(),
+          restoredAt: null,
+          status: 'archived',
+        };
+
+        const archive = await loadArchive();
+        archive.unshift(entry);
+        await saveArchive(archive);
+        await chrome.tabs.remove(toArchive.map(t => t.id));
+        pushEvent('context.sendRight', { count: toArchive.length });
+        break;
+      }
+
+      case 'comet-send-all': {
+        // Reuse the existing saveAllTabs handler
+        const handler = messageHandlers['saveAllTabs'];
+        if (handler) await handler({});
+        break;
+      }
+
+      case 'comet-exclude-domain': {
+        // Toggle exclusion for current tab's domain
+        if (!tab?.url) break;
+        const domain = getDomain(tab.url);
+        if (!domain) break;
+
+        const exclusions = await loadExclusions();
+        const idx = exclusions.indexOf(domain);
+        if (idx >= 0) {
+          // Currently excluded — remove exclusion
+          exclusions.splice(idx, 1);
+          await saveExclusions(exclusions);
+          chrome.contextMenus.update('comet-exclude-domain', {
+            title: `Exclude ${domain} from Comet`,
+          });
+          pushEvent('exclusion.removed', { domain });
+        } else {
+          // Not excluded — add exclusion
+          exclusions.push(domain);
+          await saveExclusions(exclusions);
+          chrome.contextMenus.update('comet-exclude-domain', {
+            title: `Include ${domain} in Comet (currently excluded)`,
+          });
+          pushEvent('exclusion.added', { domain });
+        }
+        break;
+      }
+    }
+  } catch (err) {
+    console.error('[Comet] Context menu action failed:', err);
+  }
+});
+
+// ─── Event Ring Buffer (Phase 1: Sub-Agent Control) ───────────────────────
+
+const MAX_EVENTS = 100;
+const eventBuffer = [];
+
+function pushEvent(type, detail) {
+  const entry = {
+    type,
+    ts: Date.now(),
+    isoTime: new Date().toISOString(),
+    ...detail,
+  };
+  eventBuffer.push(entry);
+  if (eventBuffer.length > MAX_EVENTS) {
+    eventBuffer.shift(); // FIFO eviction
+  }
+}
+
+// CDP-pollable globals
+self.__COMET_EVENTS__ = () => JSON.stringify(eventBuffer);
+self.__COMET_EVENTS_SINCE__ = (ts) =>
+  JSON.stringify(eventBuffer.filter(e => e.ts > ts));
+self.__COMET_EVENTS_COUNT__ = () => eventBuffer.length;
+
+// ─── Tab Group Listeners ──────────────────────────────────────────────────
+
+chrome.tabGroups.onCreated.addListener((group) => {
+  pushEvent('tabGroup.created', {
+    groupId: group.id,
+    title: group.title || '',
+    color: group.color,
+    windowId: group.windowId,
+    collapsed: group.collapsed,
+  });
+});
+
+chrome.tabGroups.onRemoved.addListener((group) => {
+  pushEvent('tabGroup.removed', {
+    groupId: group.id,
+    title: group.title || '',
+    color: group.color,
+  });
+});
+
+chrome.tabGroups.onUpdated.addListener((group) => {
+  pushEvent('tabGroup.updated', {
+    groupId: group.id,
+    title: group.title || '',
+    color: group.color,
+    collapsed: group.collapsed,
+    windowId: group.windowId,
+  });
+});
+
+// ─── Tab Listeners ────────────────────────────────────────────────────────
+
+chrome.tabs.onCreated.addListener((tab) => {
+  pushEvent('tab.created', {
+    tabId: tab.id,
+    groupId: tab.groupId,
+    windowId: tab.windowId,
+    url: tab.pendingUrl || tab.url || '',
+  });
+});
+
+chrome.tabs.onRemoved.addListener((tabId, removeInfo) => {
+  pushEvent('tab.removed', {
+    tabId,
+    windowId: removeInfo.windowId,
+    isWindowClosing: removeInfo.isWindowClosing,
+  });
+});
+
+chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
+  // Only fire on meaningful changes: URL, title, or group assignment
+  const dominated = changeInfo.url || changeInfo.title || ('groupId' in changeInfo);
+  if (!dominated) return;
+
+  pushEvent('tab.updated', {
+    tabId,
+    groupId: tab.groupId,
+    changes: Object.keys(changeInfo),
+    url: tab.url || '',
+    title: tab.title || '',
+  });
+});
+
+chrome.tabs.onMoved.addListener((tabId, moveInfo) => {
+  pushEvent('tab.moved', {
+    tabId,
+    windowId: moveInfo.windowId,
+    fromIndex: moveInfo.fromIndex,
+    toIndex: moveInfo.toIndex,
+  });
+});