@shawnowen/comet-mcp 2.3.1 → 2.4.2

package/extension/background.js

@@ -1,7 +1,11 @@
 // 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";
+self.__COMET_TAB_GROUPS_VERSION__ = "2.0.0";
+
+// Load shared pure logic module (Spec 036)
+importScripts("session-logic.js");
+importScripts("window-policy.js");
 
 // ─── Robust MV3 Keepalive ────────────────────────────────────────────────────
 //
@@ -20,7 +24,7 @@ let keepAlivePort = null;
 
 function connectKeepAlive() {
   try {
-    keepAlivePort = chrome.runtime.connect({ name: 'keepalive' });
+    keepAlivePort = chrome.runtime.connect({ name: "keepalive" });
     keepAlivePort.onDisconnect.addListener(() => {
       // Reading lastError clears it and prevents the "Unchecked runtime.lastError" warning
       void chrome.runtime.lastError;
@@ -35,7 +39,7 @@ function connectKeepAlive() {
 }
 
 chrome.runtime.onConnect.addListener((port) => {
-  if (port.name === 'keepalive') {
+  if (port.name === "keepalive") {
     // Accept the self-connection — its mere existence keeps us alive
     return;
   }
@@ -45,12 +49,12 @@ chrome.runtime.onConnect.addListener((port) => {
 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.create("keepalive", { periodInMinutes: 0.4167 }); // clamped to 30s minimum
 
 chrome.alarms.onAlarm.addListener((alarm) => {
-  if (alarm.name === 'keepalive') {
+  if (alarm.name === "keepalive") {
     // Real async chrome API call extends worker lifetime
-    chrome.tabs.query({ active: true, currentWindow: true }).catch(() => { });
+    chrome.tabs.query({ active: true, currentWindow: true }).catch(() => {});
     // Ensure self-port is still connected
     if (!keepAlivePort) connectKeepAlive();
   }
@@ -66,15 +70,77 @@ chrome.alarms.onAlarm.addListener((alarm) => {
 // Each handler is an async function: (payload) => data
 
 const messageHandlers = {};
+const {
+  TOP_DISPLAY_FULLSCREEN_WINDOW,
+  createTopDisplayFullscreenWindow,
+  ensureOneGroupPerWindow,
+  enforceTopDisplayFullscreenWindow,
+  isManagedWindow,
+  LOCKED_GROUPS_PER_WINDOW_POLICY,
+} = globalThis.CometWindowPolicy;
+
+function normalizeSettings(settings = {}) {
+  return {
+    ...settings,
+    groupsPerWindow: { ...LOCKED_GROUPS_PER_WINDOW_POLICY },
+  };
+}
+
+const SAFETY_REMINDER_ALLOWLIST_KEY = "safetyReminderHostAllowlist";
+const DEFAULT_SAFETY_REMINDER_HOST_ALLOWLIST =
+  globalThis.SessionLogic?.DEFAULT_SAFETY_REMINDER_HOST_ALLOWLIST || [];
+
+async function getSafetyReminderHostAllowlist() {
+  const stored = await chrome.storage.local.get(SAFETY_REMINDER_ALLOWLIST_KEY);
+  const allowlist = stored[SAFETY_REMINDER_ALLOWLIST_KEY];
+  return Array.isArray(allowlist) ? allowlist : [...DEFAULT_SAFETY_REMINDER_HOST_ALLOWLIST];
+}
+
+async function shouldInjectSafetyReminderForUrl(url) {
+  const allowlist = await getSafetyReminderHostAllowlist();
+  return globalThis.SessionLogic?.shouldInjectSafetyReminder
+    ? globalThis.SessionLogic.shouldInjectSafetyReminder(url, allowlist)
+    : true;
+}
 
 function registerHandler(type, handler) {
   messageHandlers[type] = handler;
 }
 
+let windowPolicyTimer = null;
+let windowPolicyRunning = false;
+let windowPolicyPending = false;
+let windowPolicyPendingGroupId = null;
+
+function scheduleWindowPolicyEnforcement(groupId = null, delayMs = 250) {
+  if (windowPolicyTimer) clearTimeout(windowPolicyTimer);
+  windowPolicyTimer = setTimeout(async () => {
+    if (windowPolicyRunning) {
+      windowPolicyPending = true;
+      windowPolicyPendingGroupId = groupId || windowPolicyPendingGroupId;
+      return;
+    }
+    windowPolicyRunning = true;
+    try {
+      await ensureOneGroupPerWindow(groupId);
+    } catch (err) {
+      console.warn("[Comet] Window policy enforcement failed:", err);
+    } finally {
+      windowPolicyRunning = false;
+      if (windowPolicyPending) {
+        const pendingGroupId = windowPolicyPendingGroupId;
+        windowPolicyPending = false;
+        windowPolicyPendingGroupId = null;
+        scheduleWindowPolicyEnforcement(pendingGroupId, 0);
+      }
+    }
+  }, delayMs);
+}
+
 // 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') {
+  if (msg?.type === "ping") {
     sendResponse({ pong: true, ts: Date.now(), version: self.__COMET_TAB_GROUPS_VERSION__ });
     return true;
   }
@@ -88,7 +154,7 @@ chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
   // Execute handler asynchronously, respond with contract format
   (async () => {
     try {
-      const data = await handler(msg.payload || {});
+      const data = await handler(msg.payload || {}, sender);
       sendResponse({ ok: true, data });
     } catch (err) {
       console.error(`[Comet] Handler error for "${msg.type}":`, err);
@@ -101,7 +167,7 @@ chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
 
 // Respond to messages from external extensions or CDP-injected scripts
 chrome.runtime.onMessageExternal.addListener((msg, sender, sendResponse) => {
-  if (msg?.type === 'ping') {
+  if (msg?.type === "ping") {
     sendResponse({ pong: true, ts: Date.now(), version: self.__COMET_TAB_GROUPS_VERSION__ });
     return true;
   }
@@ -110,11 +176,11 @@ chrome.runtime.onMessageExternal.addListener((msg, sender, sendResponse) => {
 // ─── Message Handlers ─────────────────────────────────────────────────────────
 
 // T005: getGroups — returns all live tab groups
-registerHandler('getGroups', async () => {
+registerHandler("getGroups", async () => {
   const groups = await chrome.tabGroups.query({});
-  return groups.map(g => ({
+  return groups.map((g) => ({
     id: g.id,
-    title: g.title || '',
+    title: g.title || "",
     color: g.color,
     collapsed: g.collapsed,
     windowId: g.windowId,
@@ -122,22 +188,66 @@ registerHandler('getGroups', async () => {
 });
 
 // T006: getTabs — returns all tabs with group/window info
-registerHandler('getTabs', async () => {
+registerHandler("getTabs", async () => {
   const tabs = await chrome.tabs.query({});
-  return tabs.map(t => ({
+  return tabs.map((t) => ({
     id: t.id,
     groupId: t.groupId,
     windowId: t.windowId,
     index: t.index,
-    title: t.title || '',
-    url: t.url || '',
+    title: t.title || "",
+    url: t.url || "",
     active: t.active,
-    favIconUrl: t.favIconUrl || '',
+    favIconUrl: t.favIconUrl || "",
   }));
 });
 
+// Equanaut Input Gateway — telemetry only. The actual LLM fetch happens in
+// the side-panel context (sidepanel.js) because MV3 service workers need
+// host_permissions for cross-origin fetch and we want to avoid that upgrade.
+registerHandler(
+  "equanautGatewaySubmit",
+  async ({
+    text,
+    contextLabel,
+    attachments,
+    windowId,
+    scopedGroupCount,
+    scopedTabCount,
+    slashCommandId,
+    slashCommandResolved,
+  }) => {
+    pushEvent("equanaut.gateway.submit", {
+      textLength: typeof text === "string" ? text.length : 0,
+      hasContext: Boolean(contextLabel && String(contextLabel).trim()),
+      attachmentCount: Array.isArray(attachments) ? attachments.length : 0,
+      windowId: windowId ? String(windowId) : "",
+      scopedGroupCount: Number(scopedGroupCount) || 0,
+      scopedTabCount: Number(scopedTabCount) || 0,
+      slashCommandId: slashCommandId ? String(slashCommandId) : null,
+      slashCommandResolved: Boolean(slashCommandResolved),
+    });
+    return { accepted: true };
+  }
+);
+
+registerHandler("equanautGatewayAttach", async () => {
+  pushEvent("equanaut.gateway.attach", {});
+  return { acknowledged: true };
+});
+
+registerHandler("equanautGatewaySparkle", async () => {
+  pushEvent("equanaut.gateway.sparkle", {});
+  return { acknowledged: true };
+});
+
+registerHandler("equanautGatewayMic", async ({ action }) => {
+  pushEvent("equanaut.gateway.mic", { action: action || "click" });
+  return { acknowledged: true };
+});
+
 // T007: healthCheck — checks CDP bridge presence and returns version
-registerHandler('healthCheck', async () => {
+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;
@@ -154,50 +264,528 @@ registerHandler('healthCheck', async () => {
   };
 });
 
+registerHandler("getSafetyReminderHostAllowlist", async () => ({
+  allowlist: await getSafetyReminderHostAllowlist(),
+}));
+
+registerHandler("updateSafetyReminderHostAllowlist", async ({ allowlist }) => {
+  if (!Array.isArray(allowlist)) throw new Error("allowlist must be an array");
+  const normalized = allowlist.map((value) => String(value).trim()).filter(Boolean);
+  await chrome.storage.local.set({ [SAFETY_REMINDER_ALLOWLIST_KEY]: normalized });
+  return { allowlist: normalized };
+});
+
+registerHandler("shouldInjectSafetyReminder", async ({ url }) => ({
+  inject: await shouldInjectSafetyReminderForUrl(url),
+}));
+
+// ─── Display & Window Handlers (T101, T102) ─────────────────────────────────
+
+// T101: getDisplays — returns all connected displays with bounds
+registerHandler("getDisplays", async () => {
+  try {
+    const displays = await chrome.system.display.getInfo();
+    return displays.map((d) => ({
+      id: d.id,
+      name: d.name || `Display ${d.id}`,
+      bounds: d.bounds, // { left, top, width, height }
+      isPrimary: d.isPrimary || false,
+    }));
+  } catch {
+    // Fallback: chrome.system.display may not be available in all Chromium forks
+    return [];
+  }
+});
+
+// T102: getWindowDisplayMapping — maps each window to its display by position
+registerHandler("getWindowDisplayMapping", async () => {
+  const [displays, windows] = await Promise.all([
+    chrome.system.display.getInfo().catch(() => []),
+    chrome.windows.getAll({ populate: false }),
+  ]);
+
+  const mapping = {};
+
+  for (const win of windows) {
+    if (win.type !== "normal") continue;
+
+    // Minimized windows have no useful position — assign to primary display
+    if (win.state === "minimized" || win.top == null || win.left == null) {
+      const primary = displays.find((d) => d.isPrimary) || displays[0];
+      mapping[win.id] = primary ? primary.id : "unknown";
+      continue;
+    }
+
+    // Find the display whose bounds contain the window's top-left corner
+    // If window spans multiple displays, pick the one with most overlap
+    let bestDisplay = null;
+    let bestOverlap = -1;
+
+    for (const d of displays) {
+      const b = d.bounds;
+      const overlapLeft = Math.max(win.left, b.left);
+      const overlapTop = Math.max(win.top, b.top);
+      const overlapRight = Math.min(win.left + win.width, b.left + b.width);
+      const overlapBottom = Math.min(win.top + win.height, b.top + b.height);
+      const overlap =
+        Math.max(0, overlapRight - overlapLeft) * Math.max(0, overlapBottom - overlapTop);
+
+      if (overlap > bestOverlap) {
+        bestOverlap = overlap;
+        bestDisplay = d;
+      }
+    }
+
+    if (bestDisplay) {
+      mapping[win.id] = bestDisplay.id;
+    } else if (displays.length === 0) {
+      // No display API — fall back to y-position heuristic
+      mapping[win.id] = win.top < 0 ? "top" : "bottom";
+    } else {
+      mapping[win.id] = "unknown";
+    }
+  }
+
+  return mapping;
+});
+
+// ─── Fullscreen/Side Panel Handlers (T009-T013, T063) ───────────────────────
+
+const SESSION_MANAGER_URL = chrome.runtime.getURL("session-manager.html");
+
+registerHandler("openSidePanel", async () => {
+  try {
+    const win = await chrome.windows.getLastFocused();
+    await chrome.sidePanel.open({ windowId: win.id });
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+});
+
+// T009: expandToFullTab — close sidepanel, open full-tab
+registerHandler("expandToFullTab", async () => {
+  // Disable sidepanel to force-close it
+  await chrome.sidePanel.setOptions({ enabled: false });
+  // Open session-manager.html as a new tab
+  await chrome.tabs.create({ url: SESSION_MANAGER_URL });
+  // Re-enable sidepanel after a delay (so it's available again later)
+  setTimeout(() => {
+    chrome.sidePanel.setOptions({ enabled: true });
+  }, 500);
+  return { ok: true };
+});
+
+// T010: minimizeToSidepanel — close full-tab, reopen sidepanel
+registerHandler("minimizeToSidepanel", async (payload, sender) => {
+  // Open sidepanel first
+  const win = await chrome.windows.getLastFocused();
+  await chrome.sidePanel.open({ windowId: win.id });
+  // Close the requesting tab (the session-manager.html full-tab)
+  // The sender tab is passed via the message dispatcher
+  if (sender?.tab?.id) {
+    await chrome.tabs.remove(sender.tab.id).catch(() => {});
+  }
+  return { ok: true };
+});
+
+// T011: Conflict detection — if session-manager.html is opened while sidepanel is active
+chrome.tabs.onCreated.addListener(async (tab) => {
+  // Check after a short delay for the URL to be set
+  setTimeout(async () => {
+    try {
+      const updated = await chrome.tabs.get(tab.id);
+      if (updated.url && updated.url.startsWith(SESSION_MANAGER_URL)) {
+        // Full-tab opened — disable sidepanel to prevent dual view
+        await chrome.sidePanel.setOptions({ enabled: false });
+        setTimeout(() => chrome.sidePanel.setOptions({ enabled: true }), 500);
+      }
+    } catch {
+      // Tab may have been closed
+    }
+  }, 200);
+});
+
+// T011: If session-manager.html closes unexpectedly, re-enable sidepanel
+chrome.tabs.onRemoved.addListener(async (tabId, removeInfo) => {
+  // Check if any remaining session-manager.html tabs exist
+  try {
+    const tabs = await chrome.tabs.query({});
+    const hasFullTab = tabs.some((t) => t.url && t.url.startsWith(SESSION_MANAGER_URL));
+    if (!hasFullTab) {
+      // No full-tab remains — ensure sidepanel is re-enabled
+      await chrome.sidePanel.setOptions({ enabled: true });
+    }
+  } catch {
+    // ignore
+  }
+});
+
+// ─── Extension Icon Click — Save & Close (T015-T017) ────────────────────────
+
+chrome.action.onClicked.addListener(async (tab) => {
+  const currentWindowId = tab.windowId;
+
+  // Query all tabs in the current window
+  const allTabs = await chrome.tabs.query({ windowId: currentWindowId });
+  const saveTabs = allTabs.filter(
+    (t) => !t.url?.startsWith("chrome-extension://") && !t.url?.startsWith("chrome://")
+  );
+
+  // T017: Edge case — no saveable tabs
+  if (!saveTabs.length) {
+    // Just open the sidepanel
+    try {
+      await chrome.sidePanel.open({ windowId: currentWindowId });
+    } catch {
+      // ignore
+    }
+    return;
+  }
+
+  // Get group info for enrichment
+  const groups = await chrome.tabGroups.query({ windowId: currentWindowId });
+  const groupMap = new Map(groups.map((g) => [g.id, g]));
+
+  // Group tabs by their groupId
+  const byGroup = new Map();
+  for (const t of saveTabs) {
+    const gid = t.groupId !== -1 ? t.groupId : "ungrouped";
+    if (!byGroup.has(gid)) byGroup.set(gid, []);
+    byGroup.get(gid).push(t);
+  }
+
+  // Build RecentlyClosedGroup entries and save to archive
+  const archive = await loadArchive();
+
+  for (const [gid, tabs] of byGroup) {
+    const groupInfo = gid !== "ungrouped" ? groupMap.get(gid) : null;
+    // Spec 037: Fetch session data from HTTP bridge for orchestrator URL
+    let sessionData = null;
+    const threadId = generateId();
+    try {
+      const groupTitle = groupInfo?.title || "";
+      const sessionRes = await fetch(
+        `http://localhost:3456/api/session/${encodeURIComponent(groupTitle)}`
+      );
+      if (sessionRes.ok) sessionData = await sessionRes.json();
+    } catch {
+      /* HTTP bridge unavailable — proceed without session data */
+    }
+
+    const entry = {
+      taskThreadId: threadId,
+      // T016: Handle ungrouped tabs as "Unnamed" group
+      title: groupInfo?.title || (gid === "ungrouped" ? "Ungrouped Tabs" : "Untitled"),
+      color: groupInfo?.color || "grey",
+      collapsed: false,
+      urls: tabs.map((t) => ({
+        url: t.url || "",
+        title: t.title || "",
+        favIconUrl: t.favIconUrl || "",
+      })),
+      archivedAt: new Date().toISOString(),
+      restoredAt: null,
+      status: "pending",
+      // Spec 037: Orchestrator session data
+      orchestratorUrl: sessionData?.orchestratorUrl || null,
+      taskGoal: sessionData?.taskGoal || null,
+      sessionName: sessionData?.sessionName || null,
+    };
+    archive.unshift(entry);
+  }
+
+  await saveArchive(archive);
+
+  // Close all saved tabs and open full-screen session manager
+  const tabIds = saveTabs.map((t) => t.id);
+  const fullUrl = chrome.runtime.getURL("session-manager.html");
+  await chrome.tabs.create({ windowId: currentWindowId, url: fullUrl, active: true });
+  await chrome.tabs.remove(tabIds);
+
+  pushEvent("icon.saveAndClose", { groupCount: byGroup.size, tabCount: saveTabs.length });
+});
+
+// ─── Settings Handlers (T058-T059) ───────────────────────────────────────────
+
+registerHandler("getSettings", async () => {
+  const stored = await chrome.storage.local.get("sidebarSettings");
+  return normalizeSettings(stored.sidebarSettings || {});
+});
+
+registerHandler("updateSettings", async (settings) => {
+  await chrome.storage.local.set({ sidebarSettings: normalizeSettings(settings) });
+  return { ok: true };
+});
+
+// T058: Hard limit enforcement — best-effort, closes violating tabs/groups
+let hardLimitSettings = null;
+
+// Load settings on startup
+chrome.storage.local.get("sidebarSettings").then((stored) => {
+  hardLimitSettings = normalizeSettings(stored.sidebarSettings || {});
+});
+
+// Watch for settings changes
+chrome.storage.onChanged.addListener((changes) => {
+  if (changes.sidebarSettings) {
+    hardLimitSettings = normalizeSettings(changes.sidebarSettings.newValue || {});
+  }
+});
+
+// Clarification Q1 Session 2: Hard limits degrade to soft warnings for browser-native
+// tab creation. Only extension-initiated actions (archive restore, import) are truly blocked.
+// Browser-native tabs are never auto-closed; instead we push a warning event to the sidebar.
+chrome.tabs.onCreated.addListener(async (tab) => {
+  if (!hardLimitSettings) return;
+  const tpg = hardLimitSettings.tabsPerGroup;
+  if (!tpg || tpg.mode !== "hard") return;
+
+  await new Promise((r) => setTimeout(r, 200));
+
+  try {
+    const updated = await chrome.tabs.get(tab.id);
+    if (updated.groupId === -1) return;
+
+    const groupTabs = await chrome.tabs.query({ groupId: updated.groupId });
+    if (groupTabs.length > tpg.value) {
+      // Don't close — degrade to warning for browser-native actions
+      console.log(
+        `[Settings] Hard limit exceeded: group ${updated.groupId} has ${groupTabs.length}/${tpg.value} tabs (warning only — native action)`
+      );
+      // Store warning for sidebar to pick up
+      const warnings = (await chrome.storage.local.get("limitWarnings")).limitWarnings || [];
+      warnings.push({
+        type: "tabsPerGroup",
+        groupId: updated.groupId,
+        actual: groupTabs.length,
+        limit: tpg.value,
+        timestamp: Date.now(),
+      });
+      // Keep only last 20 warnings
+      await chrome.storage.local.set({ limitWarnings: warnings.slice(-20) });
+    }
+  } catch {
+    // Tab may have been closed already
+  }
+});
+
+// Handler to check hard limits before extension-initiated actions (restore, import)
+registerHandler("checkHardLimit", async ({ type, count }) => {
+  if (!hardLimitSettings) return { allowed: true };
+  const setting = hardLimitSettings[type];
+  if (!setting || setting.mode !== "hard") return { allowed: true };
+  if (count >= setting.value) {
+    return { allowed: false, limit: setting.value, actual: count, type };
+  }
+  return { allowed: true };
+});
+
 // ─── Archive Storage Helpers ──────────────────────────────────────────────────
 
-const ARCHIVE_KEY = 'archivedGroups';
+const ARCHIVE_KEY = "archivedGroups";
+const SESSION_ENTITY_DESCRIPTIONS_KEY = "sessionEntityDescriptions";
+
+function normalizeDescriptionText(value) {
+  return value === undefined || value === null ? "" : String(value);
+}
+
+function normalizeInstructionText(value) {
+  return value === undefined || value === null ? "" : String(value).trim();
+}
+
+function normalizeArchiveWorkflowStatus(status) {
+  if (globalThis.SessionLogic?.normalizeArchiveWorkflowStatus) {
+    return globalThis.SessionLogic.normalizeArchiveWorkflowStatus(status);
+  }
+  const raw = String(status || "")
+    .trim()
+    .toLowerCase();
+  if (raw === "done") return "done";
+  if (raw === "trashed") return "trashed";
+  return "pending";
+}
+
+function coerceArchiveWorkflowStatusForWrite(status) {
+  const raw = String(status || "")
+    .trim()
+    .toLowerCase();
+  if (raw === "saved" || raw === "archived") return "pending";
+  if (raw === "pending" || raw === "done" || raw === "trashed") return raw;
+  throw new Error(`Invalid status: ${status}`);
+}
+
+function hasOwn(record, key) {
+  return !!record && Object.prototype.hasOwnProperty.call(record, key);
+}
+
+function normalizeRecordDescription(record) {
+  if (globalThis.SessionLogic?.normalizeEntityDescription) {
+    return globalThis.SessionLogic.normalizeEntityDescription(record);
+  }
+  if (!record || typeof record !== "object") return "";
+  if (hasOwn(record, "description")) return normalizeDescriptionText(record.description);
+  if (hasOwn(record, "note")) return normalizeDescriptionText(record.note);
+  if (hasOwn(record, "notes")) {
+    const notes = record.notes;
+    return Array.isArray(notes)
+      ? notes.map((note) => normalizeDescriptionText(note)).join("\n")
+      : normalizeDescriptionText(notes);
+  }
+  return "";
+}
+
+function entityDescriptionKey(entityType, entityId) {
+  return `${String(entityType || "").trim()}:${String(entityId || "").trim()}`;
+}
+
+async function loadEntityDescriptions() {
+  const result = await chrome.storage.local.get(SESSION_ENTITY_DESCRIPTIONS_KEY);
+  const stored = result[SESSION_ENTITY_DESCRIPTIONS_KEY];
+  return stored && typeof stored === "object" ? stored : {};
+}
+
+async function saveEntityDescriptions(descriptions) {
+  await chrome.storage.local.set({ [SESSION_ENTITY_DESCRIPTIONS_KEY]: descriptions || {} });
+}
+
+async function loadSidebarSettings() {
+  const result = await chrome.storage.local.get("sidebarSettings");
+  return result.sidebarSettings && typeof result.sidebarSettings === "object"
+    ? result.sidebarSettings
+    : {};
+}
+
+function getStoredDescription(descriptions, entityType, entityId) {
+  const key = entityDescriptionKey(entityType, entityId);
+  const entry = descriptions?.[key];
+  if (typeof entry === "string") return entry;
+  return normalizeDescriptionText(entry?.description);
+}
+
+function getStoredGroupInstructions(settings, groupId) {
+  const entry = settings?.equanautGroupInstructions?.[String(groupId)];
+  if (typeof entry === "string") return entry.trim();
+  return normalizeInstructionText(entry?.instructions);
+}
+
+function normalizeArchiveTab(tab, parentDescription = "") {
+  const normalized = typeof tab === "object" && tab ? { ...tab } : { url: String(tab || "") };
+  const explicitDescription = normalizeRecordDescription(normalized);
+  normalized.description = explicitDescription;
+  normalized.inheritedDescription = explicitDescription
+    ? ""
+    : normalizeDescriptionText(normalized.inheritedDescription || parentDescription);
+  return normalized;
+}
+
+function normalizeArchiveEntry(entry) {
+  if (!entry || typeof entry !== "object") return entry;
+  const normalized = { ...entry };
+  normalized.description = normalizeRecordDescription(normalized);
+  normalized.agentInstructions = normalizeInstructionText(normalized.agentInstructions);
+  normalized.urls = Array.isArray(normalized.urls)
+    ? normalized.urls.map((tab) => normalizeArchiveTab(tab, normalized.description))
+    : [];
+  normalized.status = normalizeArchiveWorkflowStatus(normalized.status);
+  return normalized;
+}
 
 async function loadArchive() {
   const result = await chrome.storage.local.get(ARCHIVE_KEY);
-  return result[ARCHIVE_KEY] || [];
+  const archive = result[ARCHIVE_KEY] || [];
+  return Array.isArray(archive) ? archive.map(normalizeArchiveEntry) : [];
 }
 
 async function saveArchive(entries) {
-  await chrome.storage.local.set({ [ARCHIVE_KEY]: entries });
+  await chrome.storage.local.set({
+    [ARCHIVE_KEY]: Array.isArray(entries) ? entries.map(normalizeArchiveEntry) : [],
+  });
 }
 
+registerHandler("getEntityDescriptions", async () => {
+  return await loadEntityDescriptions();
+});
+
+registerHandler("updateEntityDescription", async ({ entityType, entityId, description }) => {
+  if (!entityType || entityId === undefined || entityId === null) {
+    throw new Error("entityType and entityId are required");
+  }
+  const descriptions = await loadEntityDescriptions();
+  const key = entityDescriptionKey(entityType, entityId);
+  descriptions[key] = {
+    entityType: String(entityType),
+    entityId: String(entityId),
+    description: normalizeDescriptionText(description),
+    updatedAt: new Date().toISOString(),
+  };
+  await saveEntityDescriptions(descriptions);
+  return descriptions[key];
+});
+
 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
+async function buildArchiveEntryFromLiveGroup(groupId, title, snapshotOnly = false) {
   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';
+  const group = groups.find((g) => g.id === groupId);
+  const color = group ? group.color : "grey";
+  const windowId = group ? group.windowId : tabs[0] ? tabs[0].windowId : null;
+  let sourceDisplayId = null;
+  try {
+    const mapping = await messageHandlers["getWindowDisplayMapping"]({});
+    sourceDisplayId = mapping[windowId] || null;
+  } catch {
+    /* ignore */
+  }
+  const [descriptions, settings] = await Promise.all([
+    loadEntityDescriptions(),
+    loadSidebarSettings(),
+  ]);
+  const groupDescription = getStoredDescription(descriptions, "group", groupId);
+  const agentInstructions = getStoredGroupInstructions(settings, groupId);
 
-  // Create archive entry
-  const entry = {
+  return {
     taskThreadId: generateId(),
-    title: title || group?.title || 'Untitled',
+    title: title || group?.title || "Untitled",
+    description: groupDescription,
+    agentInstructions,
     color,
     collapsed: group?.collapsed || false,
-    urls: tabs.map(t => ({ url: t.url || '', title: t.title || '' })),
+    urls: tabs.map((t) => ({
+      url: t.url || "",
+      title: t.title || "",
+      favIconUrl: t.favIconUrl || "",
+      description: getStoredDescription(descriptions, "tab", t.id),
+      inheritedDescription: getStoredDescription(descriptions, "tab", t.id) ? "" : groupDescription,
+    })),
     archivedAt: new Date().toISOString(),
     restoredAt: null,
-    status: 'archived',
+    status: "pending",
+    sourceWindowId: windowId,
+    sourceDisplayId,
+    starred: false,
+    locked: false,
+    pinned: false,
+    note: "",
+    folderId: null,
+    snapshotOnly,
+    source: snapshotOnly ? "snapshot" : "archive",
   };
+}
+
+// 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 }) => {
+  const entry = await buildArchiveEntryFromLiveGroup(groupId, title, false);
 
   // Save to archive
   const archive = await loadArchive();
@@ -205,69 +793,416 @@ registerHandler('archiveGroup', async ({ groupId, title }) => {
   await saveArchive(archive);
 
   // Close the tabs
-  const tabIds = tabs.map(t => t.id);
+  const tabs = await chrome.tabs.query({ groupId });
+  const tabIds = tabs.map((t) => t.id);
   await chrome.tabs.remove(tabIds);
 
-  pushEvent('archive.created', { taskThreadId: entry.taskThreadId, title: entry.title, tabCount: tabs.length });
+  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 snapshotSavesInFlight = new Set();
+
+// saveGroupSnapshot — save tabs from a live group without closing or moving anything
+registerHandler("saveGroupSnapshot", async ({ groupId, title }) => {
+  const tabs = await chrome.tabs.query({ groupId });
+  if (!tabs.length) throw new Error(`No tabs found in group ${groupId}`);
+
+  const fingerprint = `${groupId}:${tabs.map((t) => `${t.id}:${t.url || ""}`).join("|")}`;
+  if (snapshotSavesInFlight.has(fingerprint)) {
+    return { duplicateIgnored: true, totalTabs: tabs.length };
+  }
+  snapshotSavesInFlight.add(fingerprint);
+
+  try {
+    const entry = await buildArchiveEntryFromLiveGroup(groupId, title, true);
+    const archive = await loadArchive();
+    archive.unshift(entry);
+    await saveArchive(archive);
+
+    pushEvent("archive.snapshotSaved", {
+      taskThreadId: entry.taskThreadId,
+      title: entry.title,
+      tabCount: entry.urls.length,
+    });
+
+    return {
+      taskThreadId: entry.taskThreadId,
+      totalTabs: entry.urls.length,
+      snapshotOnly: true,
+    };
+  } finally {
+    setTimeout(() => snapshotSavesInFlight.delete(fingerprint), 1500);
+  }
+});
+
+async function resolveRestoreTargetWindowId(sourceWindowId) {
+  const numericSourceWindowId = Number(sourceWindowId);
+  if (Number.isFinite(numericSourceWindowId)) {
+    const sourceWindow = await chrome.windows
+      .get(numericSourceWindowId, { populate: false })
+      .catch(() => null);
+    if (sourceWindow?.id) return sourceWindow.id;
+  }
+
+  const currentWindow = await chrome.windows.getCurrent({ populate: false }).catch(() => null);
+  if (currentWindow?.id) return currentWindow.id;
+
+  const focusedWindow = await chrome.windows.getLastFocused({ populate: false }).catch(() => null);
+  if (focusedWindow?.id) return focusedWindow.id;
+
+  throw new Error("Cannot resolve source window for Restore in this window");
+}
+
+// T015/T049: restoreGroup — reopen all tabs from an archive entry
+// T049: Accepts target parameter: 'newWindow' (default), 'thisWindow', 'incognito'
+registerHandler("restoreGroup", async ({ taskThreadId, target = "newWindow", sourceWindowId }) => {
   const archive = await loadArchive();
-  const idx = archive.findIndex(e => e.taskThreadId === taskThreadId);
+  const idx = archive.findIndex((e) => e.taskThreadId === taskThreadId);
   if (idx === -1) throw new Error(`Archive entry not found: ${taskThreadId}`);
 
   const entry = archive[idx];
+  if (entry.locked) throw new Error("Cannot restore a locked archive entry");
   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 });
+  if (!urls.length) throw new Error("Archive entry has no URLs");
+
+  let windowId;
+  let tabs;
+
+  if (target === "incognito") {
+    // Open in a top-display fullscreen incognito window.
+    const win = await createTopDisplayFullscreenWindow({ incognito: true });
+    windowId = win.id;
+    // Remove the default new tab in the incognito window
+    if (win.tabs && win.tabs.length === 1) {
+      const defaultTabId = win.tabs[0].id;
+      tabs = await Promise.all(
+        urls.map((u) => chrome.tabs.create({ url: u.url, windowId, active: false }))
+      );
+      await chrome.tabs.remove(defaultTabId).catch(() => {});
+    } else {
+      tabs = await Promise.all(
+        urls.map((u) => chrome.tabs.create({ url: u.url, windowId, active: false }))
+      );
+    }
+  } else if (target === "thisWindow") {
+    windowId = await resolveRestoreTargetWindowId(sourceWindowId);
+    tabs = await Promise.all(
+      urls.map((u) => chrome.tabs.create({ url: u.url, windowId, active: false }))
+    );
+  } else {
+    // 'newWindow' — default behavior: open in a top-display fullscreen window.
+    const win = await createTopDisplayFullscreenWindow({ url: urls[0].url });
+    windowId = win.id;
+    tabs = [win.tabs?.[0]].filter(Boolean);
+    for (let i = 1; i < urls.length; i++) {
+      tabs.push(await chrome.tabs.create({ url: urls[i].url, windowId, active: false }));
+    }
+  }
 
-  // Set group properties
-  await chrome.tabGroups.update(groupId, {
-    title: entry.title || 'Restored',
-    color: entry.color || 'grey',
-    collapsed: false,
-  });
+  // Group the tabs (skip for incognito — grouping may not be supported)
+  let groupId = null;
+  if (target !== "incognito") {
+    try {
+      const tabIds = tabs.map((t) => t.id);
+      groupId = await chrome.tabs.group({ tabIds });
+      await chrome.tabGroups.update(groupId, {
+        title: entry.title || "Restored",
+        color: entry.color || "grey",
+        collapsed: false,
+      });
+      if (target === "thisWindow") {
+        const enforced = await ensureOneGroupPerWindow(groupId, {
+          markChangedWindowManaged: true,
+        }).catch(() => null);
+        if (enforced?.group?.windowId) {
+          windowId = enforced.group.windowId;
+        } else {
+          const restoredGroup = await chrome.tabGroups.get(groupId).catch(() => null);
+          if (restoredGroup?.windowId) windowId = restoredGroup.windowId;
+        }
+      }
+    } catch {
+      // Grouping failed (e.g., incognito mode), tabs are still open
+    }
+  }
 
   // Update archive entry status
   archive[idx] = {
     ...entry,
-    status: 'saved',
+    status: "pending",
     restoredAt: new Date().toISOString(),
   };
   await saveArchive(archive);
 
-  pushEvent('archive.restored', { taskThreadId, title: entry.title, tabCount: urls.length, groupId });
-  return { groupId };
+  pushEvent("archive.restored", {
+    taskThreadId,
+    title: entry.title,
+    tabCount: urls.length,
+    groupId,
+    target,
+  });
+  return { groupId: groupId || null, windowId };
 });
 
 // T016: deleteArchived — remove an archive entry
-registerHandler('deleteArchived', async ({ taskThreadId }) => {
+registerHandler("deleteArchived", async ({ taskThreadId }) => {
   const archive = await loadArchive();
-  const filtered = archive.filter(e => e.taskThreadId !== taskThreadId);
+  const entry = archive.find((e) => e.taskThreadId === taskThreadId);
+  if (entry?.locked) throw new Error("Cannot delete a locked archive entry");
+  const filtered = archive.filter((e) => e.taskThreadId !== taskThreadId);
   const deleted = filtered.length < archive.length;
   await saveArchive(filtered);
 
   if (deleted) {
-    pushEvent('archive.deleted', { taskThreadId });
+    pushEvent("archive.deleted", { taskThreadId });
   }
   return { deleted };
 });
 
+// ─── T045: Pre-archive agent state check ──────────────────────────────────────
+
+registerHandler("getGroupAgentStates", async ({ groupId }) => {
+  const tabs = await chrome.tabs.query({ groupId });
+  const results = [];
+  for (const tab of tabs) {
+    const isPerplexity = (tab.url || "").includes("perplexity.ai");
+    let agentState = "idle";
+    if (isPerplexity) {
+      // Check for Perplexity's visual activity indicators via scripting
+      try {
+        const [result] = await chrome.scripting.executeScript({
+          target: { tabId: tab.id },
+          func: () => {
+            // Check for Perplexity's active indicators
+            const hasProgress = !!document.querySelector(
+              '[class*="progress"], [class*="loading"], [class*="typing"]'
+            );
+            const hasAnimation = !!document.querySelector(
+              '[class*="animate"], [class*="pulse"], [class*="spin"]'
+            );
+            const hasStopButton = !!document.querySelector(
+              'button[aria-label="Stop"], button[aria-label="Cancel"]'
+            );
+            return hasProgress || hasAnimation || hasStopButton;
+          },
+        });
+        if (result?.result) agentState = "active";
+      } catch {
+        // Script injection failed (e.g., chrome:// page), assume idle
+      }
+    }
+    results.push({ tabId: tab.id, title: tab.title || "", state: agentState, url: tab.url || "" });
+  }
+  return results;
+});
+
+// T012: Check Perplexity activity via DOM observation for a single tab
+registerHandler("checkPerplexityActivity", async ({ tabId }) => {
+  try {
+    const tab = await chrome.tabs.get(tabId);
+    if (!(tab.url || "").includes("perplexity.ai")) return { active: false };
+    const [result] = await chrome.scripting.executeScript({
+      target: { tabId },
+      func: () => {
+        const hasProgress = !!document.querySelector(
+          '[class*="progress"], [class*="loading"], [class*="typing"]'
+        );
+        const hasAnimation = !!document.querySelector(
+          '[class*="animate"], [class*="pulse"], [class*="spin"]'
+        );
+        const hasStopButton = !!document.querySelector(
+          'button[aria-label="Stop"], button[aria-label="Cancel"]'
+        );
+        return hasProgress || hasAnimation || hasStopButton;
+      },
+    });
+    return { active: !!result?.result };
+  } catch {
+    return { active: false };
+  }
+});
+
+// ─── T054: Archive Management Action Handlers ─────────────────────────────────
+
+// T051: Star/unstar an archived group
+registerHandler("starArchived", async ({ taskThreadId }) => {
+  const archive = await loadArchive();
+  const entry = archive.find((e) => e.taskThreadId === taskThreadId);
+  if (!entry) throw new Error(`Not found: ${taskThreadId}`);
+  entry.starred = !entry.starred;
+  await saveArchive(archive);
+  return { starred: entry.starred };
+});
+
+// T051: Lock/unlock an archived group
+registerHandler("lockArchived", async ({ taskThreadId }) => {
+  const archive = await loadArchive();
+  const entry = archive.find((e) => e.taskThreadId === taskThreadId);
+  if (!entry) throw new Error(`Not found: ${taskThreadId}`);
+  entry.locked = !entry.locked;
+  await saveArchive(archive);
+  return { locked: entry.locked };
+});
+
+// T051: Pin/unpin an archived group
+registerHandler("pinArchived", async ({ taskThreadId }) => {
+  const archive = await loadArchive();
+  const entry = archive.find((e) => e.taskThreadId === taskThreadId);
+  if (!entry) throw new Error(`Not found: ${taskThreadId}`);
+  entry.pinned = !entry.pinned;
+  await saveArchive(archive);
+  return { pinned: entry.pinned };
+});
+
+// T051: Update note on archived group
+registerHandler("updateArchiveNote", async ({ taskThreadId, note }) => {
+  const archive = await loadArchive();
+  const entry = archive.find((e) => e.taskThreadId === taskThreadId);
+  if (!entry) throw new Error(`Not found: ${taskThreadId}`);
+  entry.description = normalizeDescriptionText(note);
+  await saveArchive(archive);
+  return { description: entry.description, note: entry.description };
+});
+
+registerHandler("updateArchiveDescription", async ({ taskThreadId, description }) => {
+  const archive = await loadArchive();
+  const entry = archive.find((e) => e.taskThreadId === taskThreadId);
+  if (!entry) throw new Error(`Not found: ${taskThreadId}`);
+  entry.description = normalizeDescriptionText(description);
+  await saveArchive(archive);
+  return { description: entry.description };
+});
+
+// T052: Update workflow status (pending, done, trashed; legacy aliases saved/archived)
+registerHandler("updateArchiveStatus", async ({ taskThreadId, status }) => {
+  const nextStatus = coerceArchiveWorkflowStatusForWrite(status);
+  const archive = await loadArchive();
+  const entry = archive.find((e) => e.taskThreadId === taskThreadId);
+  if (!entry) throw new Error(`Not found: ${taskThreadId}`);
+  if (entry.locked) throw new Error("Cannot change status of a locked entry");
+  entry.status = nextStatus;
+  await saveArchive(archive);
+  return { status: entry.status };
+});
+
+// T026: Update folder assignment for an archived entry
+registerHandler("updateArchiveFolder", async ({ taskThreadId, folder }) => {
+  const archive = await loadArchive();
+  const entry = archive.find((e) => e.taskThreadId === taskThreadId);
+  if (!entry) throw new Error(`Not found: ${taskThreadId}`);
+  if (folder === null || folder === undefined) {
+    delete entry.folder;
+  } else {
+    entry.folder = String(folder).trim();
+  }
+  await saveArchive(archive);
+  pushEvent("archive.updated", { taskThreadId, field: "folder", value: entry.folder || null });
+  return { folder: entry.folder || null };
+});
+
+// T053: Remove duplicate URLs within an archived group
+registerHandler("removeDuplicates", async ({ taskThreadId }) => {
+  const archive = await loadArchive();
+  const entry = archive.find((e) => e.taskThreadId === taskThreadId);
+  if (!entry) throw new Error(`Not found: ${taskThreadId}`);
+  if (entry.locked) throw new Error("Cannot modify a locked entry");
+  const seen = new Set();
+  const original = entry.urls.length;
+  entry.urls = entry.urls.filter((u) => {
+    if (seen.has(u.url)) return false;
+    seen.add(u.url);
+    return true;
+  });
+  await saveArchive(archive);
+  return { removed: original - entry.urls.length, remaining: entry.urls.length };
+});
+
+// T053: Sort archived groups
+registerHandler("sortArchive", async ({ sortBy = "date" }) => {
+  const archive = await loadArchive();
+  // Pinned items stay at top
+  const pinned = archive.filter((e) => e.pinned);
+  const unpinned = archive.filter((e) => !e.pinned);
+  if (sortBy === "name") {
+    unpinned.sort((a, b) => (a.title || "").localeCompare(b.title || ""));
+  } else if (sortBy === "tabs") {
+    unpinned.sort((a, b) => (b.urls?.length || 0) - (a.urls?.length || 0));
+  } else {
+    // date (default) — newest first
+    unpinned.sort((a, b) => new Date(b.archivedAt) - new Date(a.archivedAt));
+  }
+  await saveArchive([...pinned, ...unpinned]);
+  return { sorted: true, sortBy };
+});
+
+// Reorder archive entries by ID list
+registerHandler("reorderArchive", async ({ order }) => {
+  const archive = await loadArchive();
+  const byId = new Map(archive.map((e) => [e.taskThreadId || e.id, e]));
+  const reordered = [];
+  for (const id of order) {
+    const entry = byId.get(id);
+    if (entry) {
+      reordered.push(entry);
+      byId.delete(id);
+    }
+  }
+  // Append any entries not in the order list (safety)
+  for (const entry of byId.values()) reordered.push(entry);
+  await saveArchive(reordered);
+  return { ok: true };
+});
+
+// Update arbitrary fields on an archive entry (color, description, notes, etc.)
+registerHandler("updateArchiveEntry", async ({ taskThreadId, updates }) => {
+  const archive = await loadArchive();
+  const entry = archive.find((e) => e.taskThreadId === taskThreadId);
+  if (!entry) throw new Error(`Not found: ${taskThreadId}`);
+  // Only allow safe fields
+  const allowed = [
+    "color",
+    "title",
+    "description",
+    "agentInstructions",
+    "notes",
+    "folder",
+    "status",
+    "urls",
+  ];
+  for (const key of Object.keys(updates)) {
+    if (allowed.includes(key)) entry[key] = updates[key];
+  }
+  if (!hasOwn(updates, "description") && hasOwn(updates, "notes")) {
+    entry.description = normalizeRecordDescription({ notes: updates.notes });
+  }
+  await saveArchive(archive);
+  return { ok: true };
+});
+
+// T051: Copy archived group URLs to clipboard (returns URL list as text)
+registerHandler("getArchiveUrls", async ({ taskThreadId }) => {
+  const archive = await loadArchive();
+  const entry = archive.find((e) => e.taskThreadId === taskThreadId);
+  if (!entry) throw new Error(`Not found: ${taskThreadId}`);
+  const text = entry.urls.map((u) => `${u.url} | ${u.title}`).join("\n");
+  return { text, urlCount: entry.urls.length };
+});
+
 // ─── OneTab Parity Handlers ──────────────────────────────────────────────────
 
 // saveAllTabs — archive ALL open tab groups in one click (like OneTab's "Store all")
-registerHandler('saveAllTabs', async () => {
+registerHandler("saveAllTabs", async () => {
   const groups = await chrome.tabGroups.query({});
   const allTabs = await chrome.tabs.query({});
+  const [descriptions, settings] = await Promise.all([
+    loadEntityDescriptions(),
+    loadSidebarSettings(),
+  ]);
 
   if (!groups.length && !allTabs.length) {
     return { archived: 0, totalTabs: 0 };
@@ -280,42 +1215,61 @@ registerHandler('saveAllTabs', async () => {
 
   // Archive each tab group
   for (const group of groups) {
-    const groupTabs = allTabs.filter(t => t.groupId === group.id);
+    const groupTabs = allTabs.filter((t) => t.groupId === group.id);
     if (!groupTabs.length) continue;
+    const groupDescription = getStoredDescription(descriptions, "group", group.id);
+    const agentInstructions = getStoredGroupInstructions(settings, group.id);
 
     const entry = {
       taskThreadId: generateId(),
-      title: group.title || 'Untitled',
-      color: group.color || 'grey',
+      title: group.title || "Untitled",
+      description: groupDescription,
+      agentInstructions,
+      color: group.color || "grey",
       collapsed: false,
-      urls: groupTabs.map(t => ({ url: t.url || '', title: t.title || '' })),
+      urls: groupTabs.map((t) => {
+        const tabDescription = getStoredDescription(descriptions, "tab", t.id);
+        return {
+          url: t.url || "",
+          title: t.title || "",
+          favIconUrl: t.favIconUrl || "",
+          description: tabDescription,
+          inheritedDescription: tabDescription ? "" : groupDescription,
+        };
+      }),
       archivedAt: new Date().toISOString(),
       restoredAt: null,
-      status: 'archived',
+      status: "pending",
     };
     archive.unshift(entry);
     archivedCount++;
     totalTabs += groupTabs.length;
-    tabIdsToClose.push(...groupTabs.map(t => t.id));
+    tabIdsToClose.push(...groupTabs.map((t) => t.id));
   }
 
   // Archive ungrouped tabs as a separate group
-  const ungroupedTabs = allTabs.filter(t => t.groupId === -1 && !t.pinned);
+  const ungroupedTabs = allTabs.filter((t) => t.groupId === -1 && !t.pinned);
   if (ungroupedTabs.length > 0) {
     const entry = {
       taskThreadId: generateId(),
-      title: 'Ungrouped Tabs',
-      color: 'grey',
+      title: "Ungrouped Tabs",
+      description: "",
+      color: "grey",
       collapsed: false,
-      urls: ungroupedTabs.map(t => ({ url: t.url || '', title: t.title || '' })),
+      urls: ungroupedTabs.map((t) => ({
+        url: t.url || "",
+        title: t.title || "",
+        favIconUrl: t.favIconUrl || "",
+        description: getStoredDescription(descriptions, "tab", t.id),
+      })),
       archivedAt: new Date().toISOString(),
       restoredAt: null,
-      status: 'archived',
+      status: "pending",
     };
     archive.unshift(entry);
     archivedCount++;
     totalTabs += ungroupedTabs.length;
-    tabIdsToClose.push(...ungroupedTabs.map(t => t.id));
+    tabIdsToClose.push(...ungroupedTabs.map((t) => t.id));
   }
 
   await saveArchive(archive);
@@ -323,133 +1277,205 @@ registerHandler('saveAllTabs', async () => {
   // 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.create({ url: "chrome://newtab", active: true });
     await chrome.tabs.remove(tabIdsToClose);
   }
 
-  pushEvent('archive.savedAll', { groupCount: archivedCount, tabCount: totalTabs });
+  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');
+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');
+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);
+  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 });
+  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,
-  }));
+// T020: getRecentlyClosed — returns recently closed tabs/windows + group metadata
+registerHandler("getRecentlyClosed", async ({ maxResults = 25 } = {}) => {
+  const [sessions, recentGroups, descriptions] = await Promise.all([
+    chrome.sessions.getRecentlyClosed({ maxResults }),
+    loadRecentGroups(),
+    loadEntityDescriptions(),
+  ]);
+
+  // Build a URL→group lookup from our enriched storage for individual tabs
+  const urlGroupMap = new Map(); // url → { groupTitle, groupColor, groupId }
+  for (const g of recentGroups) {
+    for (const t of g.tabs) {
+      // Use URL as key — if same URL appears in multiple groups, newest wins
+      if (!urlGroupMap.has(t.url)) {
+        urlGroupMap.set(t.url, {
+          groupTitle: g.groupTitle,
+          groupColor: g.groupColor,
+          groupId: g.id,
+        });
+      }
+    }
+  }
+
+  return {
+    sessions: 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 || "",
+            description: getStoredDescription(
+              descriptions,
+              "recent",
+              s.tab?.sessionId || s.window?.sessionId || ""
+            ),
+            // Enriched group metadata from our snapshot
+            groupTitle: urlGroupMap.get(s.tab.url || "")?.groupTitle || "",
+            groupColor: urlGroupMap.get(s.tab.url || "")?.groupColor || "",
+            groupId: urlGroupMap.get(s.tab.url || "")?.groupId || "",
+          }
+        : null,
+      window: s.window
+        ? {
+            tabs: (s.window.tabs || []).map((t) => ({
+              title: t.title || "",
+              url: t.url || "",
+              favIconUrl: t.favIconUrl || "",
+              description: normalizeRecordDescription(t),
+              groupTitle: urlGroupMap.get(t.url || "")?.groupTitle || "",
+              groupColor: urlGroupMap.get(t.url || "")?.groupColor || "",
+              groupId: urlGroupMap.get(t.url || "")?.groupId || "",
+            })),
+          }
+        : null,
+    })),
+    // Also return the full group entries for folder rendering
+    recentGroups: recentGroups.map((g) => ({
+      id: g.id,
+      groupTitle: g.groupTitle,
+      groupColor: g.groupColor,
+      description:
+        getStoredDescription(descriptions, "recent", g.id) || normalizeRecordDescription(g),
+      closedAt: g.closedAt,
+      tabs: (g.tabs || []).map((tab) => normalizeArchiveTab(tab, normalizeRecordDescription(g))),
+    })),
+  };
 });
 
 // T021: restoreClosed — restore a recently closed tab or window
-registerHandler('restoreClosed', async ({ sessionId }) => {
+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');
+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 groupDescription = normalizeRecordDescription(group);
     const entry = {
       taskThreadId: generateId(),
-      title: group.name || 'Imported',
-      color: 'grey',
+      title: group.name || "Imported",
+      description: groupDescription,
+      color: "grey",
       collapsed: false,
-      urls: (group.urls || []).map(u => ({ url: u.url || '', title: u.title || '' })),
+      urls: (group.urls || []).map((u) => ({
+        url: u.url || "",
+        title: u.title || "",
+        description: normalizeRecordDescription(u),
+        inheritedDescription: normalizeRecordDescription(u) ? "" : groupDescription,
+      })),
       archivedAt: new Date().toISOString(),
       restoredAt: null,
-      status: 'archived',
+      status: "pending",
     };
     archive.unshift(entry);
     imported += entry.urls.length;
   }
 
   await saveArchive(archive);
-  pushEvent('archive.imported', { groupCount: groups.length, urlCount: imported });
+  pushEvent("archive.imported", { groupCount: groups.length, urlCount: imported });
   return { imported };
 });
 
-// T032: focusTab — switch browser focus to a specific tab
-registerHandler('focusTab', async ({ tabId, windowId }) => {
+// T032: focusTab — activate a tab without taking OS window focus
+registerHandler("focusTab", async ({ tabId, windowId }) => {
   await chrome.tabs.update(tabId, { active: true });
   if (windowId) {
-    await chrome.windows.update(windowId, { focused: true });
+    await chrome.windows.update(windowId, { focused: false });
   }
   return {};
 });
 
 // T033: closeTab — close a single tab
-registerHandler('closeTab', async ({ tabId }) => {
+registerHandler("closeTab", async ({ tabId }) => {
   await chrome.tabs.remove(tabId);
   return {};
 });
 
 // T034: closeGroup — close all tabs in a group
-registerHandler('closeGroup', async ({ groupId }) => {
+registerHandler("closeGroup", async ({ groupId }) => {
   const tabs = await chrome.tabs.query({ groupId });
   if (tabs.length) {
-    await chrome.tabs.remove(tabs.map(t => t.id));
+    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([
+registerHandler("exportAll", async () => {
+  const [groups, tabs, archived, descriptions] = await Promise.all([
     chrome.tabGroups.query({}),
     chrome.tabs.query({}),
     loadArchive(),
+    loadEntityDescriptions(),
   ]);
 
   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 || '',
-        })),
+      windows: [...new Set(tabs.map((t) => t.windowId).filter((id) => id !== undefined))].map(
+        (windowId) => ({
+          id: windowId,
+          description: getStoredDescription(descriptions, "window", windowId),
+        })
+      ),
+      groups: groups.map((g) => ({
+        id: g.id,
+        title: g.title || "",
+        description: getStoredDescription(descriptions, "group", g.id),
+        color: g.color,
+        collapsed: g.collapsed,
+        windowId: g.windowId,
+        tabs: tabs
+          .filter((t) => t.groupId === g.id)
+          .map((t) => ({
+            id: t.id,
+            title: t.title || "",
+            url: t.url || "",
+            description: getStoredDescription(descriptions, "tab", t.id),
+          })),
       })),
     },
     archived,
@@ -463,12 +1489,12 @@ async function importArchiveFromJsonFile() {
   try {
     const existing = await loadArchive();
     if (existing.length > 0) {
-      console.log('[Comet] Archive already has data, skipping file import.');
+      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');
+    const flags = await chrome.storage.local.get("archiveImportAttempted");
     if (flags.archiveImportAttempted) return;
     await chrome.storage.local.set({ archiveImportAttempted: true });
 
@@ -480,22 +1506,22 @@ async function importArchiveFromJsonFile() {
     //
     // We still attempt a fetch as a best-effort approach:
     const archivePaths = [
-      'file://' + (globalThis.__COMET_DATA_DIR || '') + '/browser/tab-groups-archive.json',
+      "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;
+      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));
+            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 });
+              pushEvent("archive.fileImported", { count: newEntries.length });
               console.log(`[Comet] Imported ${newEntries.length} entries from archive file.`);
             }
             return;
@@ -506,14 +1532,14 @@ async function importArchiveFromJsonFile() {
       }
     }
 
-    console.log('[Comet] Archive file import: no file accessible. Use CLI or UI import instead.');
+    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);
+    console.log("[Comet] Archive file import skipped:", err.message);
   }
 }
 
 chrome.runtime.onInstalled.addListener(() => {
-  chrome.alarms.create('keepalive', { periodInMinutes: 0.4167 });
+  chrome.alarms.create("keepalive", { periodInMinutes: 0.4167 });
   if (!keepAlivePort) connectKeepAlive();
   // Attempt one-time archive import
   importArchiveFromJsonFile();
@@ -523,7 +1549,7 @@ chrome.runtime.onInstalled.addListener(() => {
 
 // ─── Domain Exclusion Storage ─────────────────────────────────────────────────
 
-const EXCLUSIONS_KEY = 'excludedDomains';
+const EXCLUSIONS_KEY = "excludedDomains";
 
 async function loadExclusions() {
   const result = await chrome.storage.local.get(EXCLUSIONS_KEY);
@@ -536,42 +1562,42 @@ async function saveExclusions(domains) {
 
 function getDomain(url) {
   try {
-    return new URL(url).hostname.replace(/^www\./, '');
+    return new URL(url).hostname.replace(/^www\./, "");
   } catch {
-    return '';
+    return "";
   }
 }
 
 function isExcluded(url, exclusions) {
   const domain = getDomain(url);
-  return exclusions.some(d => domain === d || domain.endsWith('.' + d));
+  return exclusions.some((d) => domain === d || domain.endsWith("." + d));
 }
 
 // Message handlers for exclusions
-registerHandler('getExclusions', async () => {
+registerHandler("getExclusions", async () => {
   return await loadExclusions();
 });
 
-registerHandler('addExclusion', async ({ domain }) => {
-  if (!domain) throw new Error('Domain required');
+registerHandler("addExclusion", async ({ domain }) => {
+  if (!domain) throw new Error("Domain required");
   const exclusions = await loadExclusions();
-  const clean = domain.replace(/^www\./, '').toLowerCase();
+  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 });
+    pushEvent("exclusion.added", { domain: clean });
   }
   return { exclusions };
 });
 
-registerHandler('removeExclusion', async ({ domain }) => {
-  if (!domain) throw new Error('Domain required');
+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);
+  const clean = domain.replace(/^www\./, "").toLowerCase();
+  const filtered = exclusions.filter((d) => d !== clean);
   await saveExclusions(filtered);
-  pushEvent('exclusion.removed', { domain: clean });
+  pushEvent("exclusion.removed", { domain: clean });
   return { exclusions: filtered };
 });
 
@@ -582,120 +1608,128 @@ function createContextMenus() {
   chrome.contextMenus.removeAll(() => {
     // Parent menu
     chrome.contextMenus.create({
-      id: 'comet-parent',
-      title: 'Comet Session Manager',
-      contexts: ['all'],
+      id: "comet-parent",
+      title: "Equabotz Browser Agents",
+      contexts: ["all"],
     });
 
     // Open side panel
     chrome.contextMenus.create({
-      id: 'comet-open-sidebar',
-      parentId: 'comet-parent',
-      title: 'Open Comet Sidebar',
-      contexts: ['all'],
+      id: "comet-open-sidebar",
+      parentId: "comet-parent",
+      title: "Open Comet Sidebar",
+      contexts: ["all"],
+    });
+
+    // Open full screen session manager
+    chrome.contextMenus.create({
+      id: "comet-open-fullscreen",
+      parentId: "comet-parent",
+      title: "Open Full Screen Session Manager",
+      contexts: ["all"],
     });
 
     chrome.contextMenus.create({
-      id: 'comet-sep-1',
-      parentId: 'comet-parent',
-      type: 'separator',
-      contexts: ['all'],
+      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'],
+      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'],
+      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'],
+      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'],
+      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'],
+      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'],
+      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'],
+      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'],
+      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'],
+      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'],
+      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'],
+      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'],
+      id: "comet-exclude-domain",
+      parentId: "comet-parent",
+      title: "Exclude this domain from Comet",
+      contexts: ["all"],
     });
 
-    console.log('[Comet] Context menus created.');
+    console.log("[Comet] Context menus created.");
   });
 }
 
@@ -706,8 +1740,8 @@ chrome.tabs.onActivated.addListener(async ({ 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', {
+      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`,
@@ -723,8 +1757,7 @@ chrome.tabs.onActivated.addListener(async ({ tabId }) => {
 chrome.contextMenus.onClicked.addListener(async (info, tab) => {
   try {
     switch (info.menuItemId) {
-
-      case 'comet-open-sidebar': {
+      case "comet-open-sidebar": {
         // Open the side panel for this window
         if (tab?.windowId) {
           await chrome.sidePanel.open({ windowId: tab.windowId });
@@ -732,7 +1765,14 @@ chrome.contextMenus.onClicked.addListener(async (info, tab) => {
         break;
       }
 
-      case 'comet-send-tab': {
+      case "comet-open-fullscreen": {
+        // Open the full screen session manager in a new tab
+        const url = chrome.runtime.getURL("session-manager.html");
+        await chrome.tabs.create({ url });
+        break;
+      }
+
+      case "comet-send-tab": {
         // Archive just this one tab
         if (!tab) break;
         const exclusions = await loadExclusions();
@@ -742,36 +1782,38 @@ chrome.contextMenus.onClicked.addListener(async (info, tab) => {
         }
         const entry = {
           taskThreadId: generateId(),
-          title: tab.title || 'Single Tab',
-          color: 'grey',
+          title: tab.title || "Single Tab",
+          color: "grey",
           collapsed: false,
-          urls: [{ url: tab.url || '', title: tab.title || '' }],
+          urls: [{ url: tab.url || "", title: tab.title || "" }],
           archivedAt: new Date().toISOString(),
           restoredAt: null,
-          status: 'archived',
+          status: "pending",
         };
         // 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 */ }
+            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 });
+        pushEvent("context.sendTab", { title: entry.title, url: tab.url });
         break;
       }
 
-      case 'comet-send-window': {
+      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));
+        const eligible = windowTabs.filter((t) => !t.pinned && !isExcluded(t.url, exclusions));
         if (!eligible.length) break;
 
         // Group tabs by their tab group
@@ -784,83 +1826,85 @@ chrome.contextMenus.onClicked.addListener(async (info, tab) => {
 
         const archive = await loadArchive();
         const groups = await chrome.tabGroups.query({ windowId: tab.windowId });
-        const groupMap = new Map(groups.map(g => [g.id, g]));
+        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',
+            title: group?.title || (groupId === -1 ? "Ungrouped Tabs" : "Untitled"),
+            color: group?.color || "grey",
             collapsed: false,
-            urls: tabs.map(t => ({ url: t.url || '', title: t.title || '' })),
+            urls: tabs.map((t) => ({ url: t.url || "", title: t.title || "" })),
             archivedAt: new Date().toISOString(),
             restoredAt: null,
-            status: 'archived',
+            status: "pending",
           };
           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 });
+        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': {
+      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));
+        const eligible = groupTabs.filter((t) => !isExcluded(t.url, exclusions));
         if (!eligible.length) break;
 
-        let groupTitle = 'Untitled';
-        let groupColor = 'grey';
+        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 */ }
+          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 || '' })),
+          urls: eligible.map((t) => ({ url: t.url || "", title: t.title || "" })),
           archivedAt: new Date().toISOString(),
           restoredAt: null,
-          status: 'archived',
+          status: "pending",
         };
 
         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 });
+        await chrome.tabs.remove(eligible.map((t) => t.id));
+        pushEvent("context.sendGroup", { title: groupTitle, tabCount: eligible.length });
         break;
       }
 
-      case 'comet-send-selected': {
+      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));
+        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',
+          color: "grey",
           collapsed: false,
-          urls: eligible.map(t => ({ url: t.url || '', title: t.title || '' })),
+          urls: eligible.map((t) => ({ url: t.url || "", title: t.title || "" })),
           archivedAt: new Date().toISOString(),
           restoredAt: null,
-          status: 'archived',
+          status: "pending",
         };
 
         const archive = await loadArchive();
@@ -869,102 +1913,112 @@ chrome.contextMenus.onClicked.addListener(async (info, tab) => {
         // 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.create({
+            windowId: tab.windowId,
+            url: "chrome://newtab",
+            active: true,
+          });
         }
-        await chrome.tabs.remove(eligible.map(t => t.id));
-        pushEvent('context.sendSelected', { tabCount: eligible.length });
+        await chrome.tabs.remove(eligible.map((t) => t.id));
+        pushEvent("context.sendSelected", { tabCount: eligible.length });
         break;
       }
 
-      case 'comet-send-except': {
+      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));
+        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',
+          title: `All except: ${tab.title || "current tab"}`,
+          color: "grey",
           collapsed: false,
-          urls: toArchive.map(t => ({ url: t.url || '', title: t.title || '' })),
+          urls: toArchive.map((t) => ({ url: t.url || "", title: t.title || "" })),
           archivedAt: new Date().toISOString(),
           restoredAt: null,
-          status: 'archived',
+          status: "pending",
         };
 
         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 });
+        await chrome.tabs.remove(toArchive.map((t) => t.id));
+        pushEvent("context.sendExcept", { keptTab: tab.title, archivedCount: toArchive.length });
         break;
       }
 
-      case 'comet-send-left': {
+      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));
+        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',
+          title: `Tabs left of: ${tab.title || "current"}`,
+          color: "grey",
           collapsed: false,
-          urls: toArchive.map(t => ({ url: t.url || '', title: t.title || '' })),
+          urls: toArchive.map((t) => ({ url: t.url || "", title: t.title || "" })),
           archivedAt: new Date().toISOString(),
           restoredAt: null,
-          status: 'archived',
+          status: "pending",
         };
 
         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 });
+        await chrome.tabs.remove(toArchive.map((t) => t.id));
+        pushEvent("context.sendLeft", { count: toArchive.length });
         break;
       }
 
-      case 'comet-send-right': {
+      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));
+        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',
+          title: `Tabs right of: ${tab.title || "current"}`,
+          color: "grey",
           collapsed: false,
-          urls: toArchive.map(t => ({ url: t.url || '', title: t.title || '' })),
+          urls: toArchive.map((t) => ({ url: t.url || "", title: t.title || "" })),
           archivedAt: new Date().toISOString(),
           restoredAt: null,
-          status: 'archived',
+          status: "pending",
         };
 
         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 });
+        await chrome.tabs.remove(toArchive.map((t) => t.id));
+        pushEvent("context.sendRight", { count: toArchive.length });
         break;
       }
 
-      case 'comet-send-all': {
+      case "comet-send-all": {
         // Reuse the existing saveAllTabs handler
-        const handler = messageHandlers['saveAllTabs'];
+        const handler = messageHandlers["saveAllTabs"];
         if (handler) await handler({});
         break;
       }
 
-      case 'comet-exclude-domain': {
+      case "comet-exclude-domain": {
         // Toggle exclusion for current tab's domain
         if (!tab?.url) break;
         const domain = getDomain(tab.url);
@@ -976,27 +2030,137 @@ chrome.contextMenus.onClicked.addListener(async (info, tab) => {
           // Currently excluded — remove exclusion
           exclusions.splice(idx, 1);
           await saveExclusions(exclusions);
-          chrome.contextMenus.update('comet-exclude-domain', {
+          chrome.contextMenus.update("comet-exclude-domain", {
             title: `Exclude ${domain} from Comet`,
           });
-          pushEvent('exclusion.removed', { domain });
+          pushEvent("exclusion.removed", { domain });
         } else {
           // Not excluded — add exclusion
           exclusions.push(domain);
           await saveExclusions(exclusions);
-          chrome.contextMenus.update('comet-exclude-domain', {
+          chrome.contextMenus.update("comet-exclude-domain", {
             title: `Include ${domain} in Comet (currently excluded)`,
           });
-          pushEvent('exclusion.added', { domain });
+          pushEvent("exclusion.added", { domain });
         }
         break;
       }
     }
   } catch (err) {
-    console.error('[Comet] Context menu action failed:', err);
+    console.error("[Comet] Context menu action failed:", err);
   }
 });
 
+// ─── Tab-Group Snapshot (Recently Closed Group Tracking) ──────────────────
+//
+// chrome.sessions.getRecentlyClosed() does NOT preserve tab group metadata.
+// We maintain a live snapshot of tab→group mappings so that when a tab is
+// removed, we can record which group it belonged to. This enables the
+// Recently Closed section to render tabs grouped by their original tab group
+// folders with colors and titles — matching Live Sessions behavior.
+
+const RECENT_GROUPS_KEY = "recentlyClosedGroups";
+const MAX_RECENT_GROUPS = 50; // max group entries to retain
+
+// Live snapshot: tabId → { tabId, groupId, groupTitle, groupColor, url, title, favIconUrl }
+const tabSnapshot = new Map();
+// Live group info: groupId → { title, color }
+const groupSnapshot = new Map();
+
+// Initialize snapshots from current state
+async function initTabSnapshot() {
+  try {
+    const [tabs, groups] = await Promise.all([chrome.tabs.query({}), chrome.tabGroups.query({})]);
+    for (const g of groups) {
+      groupSnapshot.set(g.id, { title: g.title || "", color: g.color || "grey" });
+    }
+    for (const t of tabs) {
+      const gInfo = t.groupId !== -1 ? groupSnapshot.get(t.groupId) : null;
+      tabSnapshot.set(t.id, {
+        tabId: t.id,
+        groupId: t.groupId,
+        groupTitle: gInfo?.title || "",
+        groupColor: gInfo?.color || "grey",
+        url: t.url || "",
+        title: t.title || "",
+        favIconUrl: t.favIconUrl || "",
+      });
+    }
+  } catch (err) {
+    console.error("[Comet] Failed to init tab snapshot:", err);
+  }
+}
+initTabSnapshot();
+
+// Load persisted recently closed groups
+async function loadRecentGroups() {
+  const result = await chrome.storage.local.get(RECENT_GROUPS_KEY);
+  return result[RECENT_GROUPS_KEY] || [];
+}
+
+async function saveRecentGroups(entries) {
+  await chrome.storage.local.set({ [RECENT_GROUPS_KEY]: entries });
+}
+
+// Record a closed tab's group membership into recently closed groups
+async function recordClosedTab(tabInfo) {
+  if (!tabInfo || tabInfo.groupId === -1 || !tabInfo.groupTitle) return;
+
+  const [entries, descriptions] = await Promise.all([loadRecentGroups(), loadEntityDescriptions()]);
+  const closedAt = Date.now();
+  const groupDescription = getStoredDescription(descriptions, "group", tabInfo.groupId);
+  const tabDescription = getStoredDescription(descriptions, "tab", tabInfo.tabId);
+
+  // Find or create a group entry for this tab's group
+  // Merge into existing entry if same group was closed within last 5 seconds
+  // (batch closure of a tab group sends individual onRemoved events rapidly)
+  const MERGE_WINDOW_MS = 5000;
+  let groupEntry = entries.find(
+    (e) =>
+      e.groupTitle === tabInfo.groupTitle &&
+      e.groupColor === tabInfo.groupColor &&
+      closedAt - e.closedAt < MERGE_WINDOW_MS
+  );
+
+  if (groupEntry) {
+    if (!normalizeRecordDescription(groupEntry) && groupDescription) {
+      groupEntry.description = groupDescription;
+    }
+    // Add tab to existing group entry
+    groupEntry.tabs.push({
+      url: tabInfo.url,
+      title: tabInfo.title,
+      favIconUrl: tabInfo.favIconUrl,
+      description: tabDescription,
+      inheritedDescription: tabDescription ? "" : groupDescription,
+    });
+    groupEntry.closedAt = closedAt; // update to latest
+  } else {
+    // Create new group entry
+    groupEntry = {
+      id: `rcg-${generateId()}`,
+      groupTitle: tabInfo.groupTitle,
+      groupColor: tabInfo.groupColor,
+      description: groupDescription,
+      closedAt,
+      tabs: [
+        {
+          url: tabInfo.url,
+          title: tabInfo.title,
+          favIconUrl: tabInfo.favIconUrl,
+          description: tabDescription,
+          inheritedDescription: tabDescription ? "" : groupDescription,
+        },
+      ],
+    };
+    entries.unshift(groupEntry);
+  }
+
+  // Trim to max
+  while (entries.length > MAX_RECENT_GROUPS) entries.pop();
+  await saveRecentGroups(entries);
+}
+
 // ─── Event Ring Buffer (Phase 1: Sub-Agent Control) ───────────────────────
 
 const MAX_EVENTS = 100;
@@ -1017,16 +2181,17 @@ function pushEvent(type, detail) {
 
 // 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_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', {
+  groupSnapshot.set(group.id, { title: group.title || "", color: group.color || "grey" });
+  scheduleWindowPolicyEnforcement(group.id);
+  pushEvent("tabGroup.created", {
     groupId: group.id,
-    title: group.title || '',
+    title: group.title || "",
     color: group.color,
     windowId: group.windowId,
     collapsed: group.collapsed,
@@ -1034,36 +2199,77 @@ chrome.tabGroups.onCreated.addListener((group) => {
 });
 
 chrome.tabGroups.onRemoved.addListener((group) => {
-  pushEvent('tabGroup.removed', {
+  groupSnapshot.delete(group.id);
+  pushEvent("tabGroup.removed", {
     groupId: group.id,
-    title: group.title || '',
+    title: group.title || "",
     color: group.color,
   });
 });
 
 chrome.tabGroups.onUpdated.addListener((group) => {
-  pushEvent('tabGroup.updated', {
+  groupSnapshot.set(group.id, { title: group.title || "", color: group.color || "grey" });
+  scheduleWindowPolicyEnforcement(group.id);
+  // Update all tabs in this group with new title/color
+  for (const [tabId, info] of tabSnapshot) {
+    if (info.groupId === group.id) {
+      info.groupTitle = group.title || "";
+      info.groupColor = group.color || "grey";
+    }
+  }
+  pushEvent("tabGroup.updated", {
     groupId: group.id,
-    title: group.title || '',
+    title: group.title || "",
     color: group.color,
     collapsed: group.collapsed,
     windowId: group.windowId,
   });
 });
 
+chrome.windows.onFocusChanged.addListener((windowId) => {
+  if (windowId === chrome.windows.WINDOW_ID_NONE) return;
+  if (isManagedWindow(windowId)) enforceTopDisplayFullscreenWindow(windowId).catch(() => {});
+  scheduleWindowPolicyEnforcement(null, 500);
+});
+
+chrome.windows.onCreated.addListener((window) => {
+  if (!window?.id) return;
+  if (isManagedWindow(window.id)) enforceTopDisplayFullscreenWindow(window.id).catch(() => {});
+  scheduleWindowPolicyEnforcement(null, 500);
+});
+
 // ─── Tab Listeners ────────────────────────────────────────────────────────
 
 chrome.tabs.onCreated.addListener((tab) => {
-  pushEvent('tab.created', {
+  const gInfo = tab.groupId !== -1 ? groupSnapshot.get(tab.groupId) : null;
+  tabSnapshot.set(tab.id, {
+    tabId: tab.id,
+    groupId: tab.groupId,
+    groupTitle: gInfo?.title || "",
+    groupColor: gInfo?.color || "grey",
+    url: tab.pendingUrl || tab.url || "",
+    title: tab.title || "",
+    favIconUrl: tab.favIconUrl || "",
+  });
+  pushEvent("tab.created", {
     tabId: tab.id,
     groupId: tab.groupId,
     windowId: tab.windowId,
-    url: tab.pendingUrl || tab.url || '',
+    url: tab.pendingUrl || tab.url || "",
   });
 });
 
 chrome.tabs.onRemoved.addListener((tabId, removeInfo) => {
-  pushEvent('tab.removed', {
+  // Capture group info BEFORE removing from snapshot
+  const info = tabSnapshot.get(tabId);
+  tabSnapshot.delete(tabId);
+
+  // Record to recently closed groups if tab was in a named group
+  if (info && info.groupId !== -1 && info.groupTitle) {
+    recordClosedTab(info);
+  }
+
+  pushEvent("tab.removed", {
     tabId,
     windowId: removeInfo.windowId,
     isWindowClosing: removeInfo.isWindowClosing,
@@ -1071,24 +2277,95 @@ chrome.tabs.onRemoved.addListener((tabId, removeInfo) => {
 });
 
 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);
+  // Update snapshot with latest tab info
+  const gInfo = tab.groupId !== -1 ? groupSnapshot.get(tab.groupId) : null;
+  const existing = tabSnapshot.get(tabId) || {};
+  tabSnapshot.set(tabId, {
+    tabId,
+    groupId: tab.groupId,
+    groupTitle: gInfo?.title || existing.groupTitle || "",
+    groupColor: gInfo?.color || existing.groupColor || "grey",
+    url: tab.url || existing.url || "",
+    title: tab.title || existing.title || "",
+    favIconUrl: tab.favIconUrl || existing.favIconUrl || "",
+  });
+
+  // Only fire event on meaningful changes: URL, title, or group assignment
+  const dominated = changeInfo.url || changeInfo.title || "groupId" in changeInfo;
   if (!dominated) return;
 
-  pushEvent('tab.updated', {
+  pushEvent("tab.updated", {
     tabId,
     groupId: tab.groupId,
     changes: Object.keys(changeInfo),
-    url: tab.url || '',
-    title: tab.title || '',
+    url: tab.url || "",
+    title: tab.title || "",
   });
 });
 
 chrome.tabs.onMoved.addListener((tabId, moveInfo) => {
-  pushEvent('tab.moved', {
+  pushEvent("tab.moved", {
     tabId,
     windowId: moveInfo.windowId,
     fromIndex: moveInfo.fromIndex,
     toIndex: moveInfo.toIndex,
   });
 });
+
+// ─── Extension Icon Badge — Agent Count (T069-T070) ─────────────────────────
+
+const BADGE_STALE_THRESHOLD = 300000; // 5 minutes
+
+async function updateAgentBadge() {
+  try {
+    let agents = [];
+    try {
+      const res = await fetch("http://localhost:3456/api/agents");
+      if (res.ok) agents = await res.json();
+    } catch {
+      const stored = await chrome.storage.local.get("agentRegistry");
+      agents = stored.agentRegistry || [];
+    }
+
+    const active = agents.filter((a) => a.status === "working" || a.status === "active");
+    const stale = agents.filter((a) => {
+      const elapsed = Date.now() - (a.lastHeartbeat || a.lastActivity || 0);
+      return elapsed > BADGE_STALE_THRESHOLD && (a.lastHeartbeat || a.lastActivity);
+    });
+
+    if (agents.length === 0) {
+      await chrome.action.setBadgeText({ text: "" });
+      return;
+    }
+
+    await chrome.action.setBadgeText({ text: String(active.length || agents.length) });
+    if (stale.length > 0) {
+      await chrome.action.setBadgeBackgroundColor({ color: "#e74c3c" });
+    } else if (active.length > 0) {
+      await chrome.action.setBadgeBackgroundColor({ color: "#4caf50" });
+    } else {
+      await chrome.action.setBadgeBackgroundColor({ color: "#4a9eff" });
+    }
+  } catch {
+    // ignore
+  }
+}
+
+// Poll every 10 seconds
+setInterval(updateAgentBadge, 10000);
+updateAgentBadge();
+
+// ─── Auto-Categorize Ungrouped Tabs (T096-T098) ─────────────────────────────
+
+// getDomainDisplayName is provided by session-logic.js via importScripts (Spec 036)
+
+registerHandler("autoCategorize", async ({ tabs }) => {
+  if (!tabs || !tabs.length) return { groups: [] };
+  const byDomain = new Map();
+  for (const tab of tabs) {
+    const domain = getDomainDisplayName(tab.url || "");
+    if (!byDomain.has(domain)) byDomain.set(domain, []);
+    byDomain.get(domain).push(tab);
+  }
+  return { groups: [...byDomain.entries()].map(([name, tabs]) => ({ name, tabs })) };
+});