feat: add performance controls for large browser ops

- Add throttled large-operation handling for tab, group, and session commands.
- Introduce performance profiles, audible-tab aware gentle mode, and job progress tracking.
- Support background session restores with status/cancel commands and lazy placeholders.
- Expose new perf and extension CLI groups plus matching Python SDK methods.
- Preserve pinned tabs during session snapshots and debounce auto-save updates.
- Bump browser-cli and extension versions to 0.10.0 and add pytest-cov to dev deps.
- Add coverage for performance controls, background jobs, lazy restores, and tab metadata.

extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "browser-cli",
-  "version": "0.9.9",
+  "version": "0.10.0",
   "description": "Control your browser from the terminal or Python SDK",
   "permissions": [
     "tabs",

extension/src/commands/groups.ts

@@ -1,5 +1,5 @@
 // @ts-nocheck
-import { buildTabBlocks, resolveGroupId, tabInfo } from '../core';
+import { buildTabBlocks, getLargeOperationThrottle, resolveGroupId, runLargeOperation, tabInfo, throwIfJobCancelled, updateJobProgress, yieldForLargeOperation } from '../core';
 export async function groupList() {
   const groups = await chrome.tabGroups.query({});
   const all = await chrome.tabs.query({});
@@ -29,11 +29,21 @@ export async function groupQuery({ search }) {
   return groups.filter(g => g.title && g.title.toLowerCase().includes(q));
 }
 
-export async function groupClose({ groupId }) {
-  const tabs = await chrome.tabs.query({});
-  const groupTabs = tabs.filter(t => t.groupId === groupId);
-  await chrome.tabs.ungroup(groupTabs.map(t => t.id));
-  return { groupId };
+export async function groupClose({ groupId, gentleMode, __job } = {}) {
+  return runLargeOperation("group.close", async () => {
+    const tabs = await chrome.tabs.query({});
+    const groupTabs = tabs.filter(t => t.groupId === groupId);
+    const tabIds = groupTabs.map(t => t.id);
+    const throttle = await getLargeOperationThrottle(tabIds.length, gentleMode);
+    updateJobProgress(__job, { phase: "ungrouping tabs", current: 0, total: tabIds.length });
+    for (let i = 0; i < tabIds.length; i += throttle.batchSize) {
+      throwIfJobCancelled(__job);
+      await chrome.tabs.ungroup(tabIds.slice(i, i + throttle.batchSize));
+      updateJobProgress(__job, { phase: "ungrouping tabs", current: Math.min(i + throttle.batchSize, tabIds.length), total: tabIds.length });
+      await yieldForLargeOperation(i + throttle.batchSize, throttle.batchSize, throttle.pauseMs);
+    }
+    return { groupId, gentle: throttle.gentle, audible: throttle.audible };
+  });
 }
 
 export async function groupOpen({ name }) {

extension/src/commands/session.ts

@@ -1,14 +1,14 @@
 // @ts-nocheck
-import { getProfileAlias, getSessionTabs, getSessions, normalizeGroupColor } from '../core';
-export async function sessionSave({ name }) {
-  const tabs = await chrome.tabs.query({});
-  const groups = await chrome.tabGroups.query({});
+import { getLargeOperationThrottle, getProfileAlias, getSessionTabs, getSessions, normalizeGroupColor, runLargeOperation, throwIfJobCancelled, updateJobProgress, yieldForLargeOperation } from '../core';
+
+function buildSessionSnapshot(tabs, groups) {
   const groupById = new Map(groups.map(group => [group.id, group]));
-  const sessionTabs = tabs
-    .filter(tab => Boolean(tab.url))
+  return tabs
+    .filter(tab => Boolean(tab.url || tab.pendingUrl))
     .sort((a, b) => (a.windowId - b.windowId) || (a.index - b.index))
     .map(tab => {
-      const entry = { url: tab.url };
+      const entry = { url: tab.url || tab.pendingUrl };
+      if (tab.pinned) entry.pinned = true;
       if (tab.groupId >= 0) {
         const group = groupById.get(tab.groupId);
         entry.group = {
@@ -20,49 +20,110 @@ export async function sessionSave({ name }) {
       }
       return entry;
     });
+}
+
+function sessionSignature(sessionTabs) {
+  return JSON.stringify(sessionTabs.map(tab => ({
+    url: tab.url,
+    pinned: Boolean(tab.pinned),
+    group: tab.group ? {
+      key: tab.group.key || "",
+      title: tab.group.title || "",
+      color: normalizeGroupColor(tab.group.color),
+      collapsed: Boolean(tab.group.collapsed),
+    } : null,
+  })));
+}
+
+export async function sessionSave({ name }) {
+  const tabs = await chrome.tabs.query({});
+  const groups = await chrome.tabGroups.query({});
+  const sessionTabs = buildSessionSnapshot(tabs, groups);
+  const signature = sessionSignature(sessionTabs);
   const sessions = await getSessions();
   sessions[name] = {
     tabs: sessionTabs,
     urls: sessionTabs.map(tab => tab.url),
     savedAt: Date.now(),
+    signature,
   };
   await chrome.storage.local.set({ sessions });
   return { name, tabs: sessionTabs.length };
 }
 
-export async function sessionLoad({ name }) {
-  const sessions = await getSessions();
-  const session = sessions[name];
-  if (!session) throw new Error(`Session '${name}' not found`);
+function lazyPlaceholderUrl(url) {
+  const escaped = String(url).replace(/[&<>"']/g, ch => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", "\"": "&quot;", "'": "&#39;" }[ch]));
+  const html = `<!doctype html><title>Lazy tab</title><body style="font-family:sans-serif;padding:2rem"><h1>Lazy tab</h1><p>This tab will load when selected.</p><p><a href="${escaped}">${escaped}</a></p></body>`;
+  return `data:text/html;charset=utf-8,${encodeURIComponent(html)}`;
+}
 
-  const sessionTabs = getSessionTabs(session);
-  const createdTabs = [];
+export async function activateLazyTab(tabId) {
+  const { lazySessionTabs } = await chrome.storage.local.get("lazySessionTabs");
+  const entry = lazySessionTabs?.[tabId];
+  if (!entry?.url) return false;
+  delete lazySessionTabs[tabId];
+  await chrome.storage.local.set({ lazySessionTabs });
+  await chrome.tabs.update(Number(tabId), { url: entry.url });
+  return true;
+}
 
-  for (const entry of sessionTabs) {
-    const tab = await chrome.tabs.create({ url: entry.url, active: false });
-    createdTabs.push({ tabId: tab.id, entry });
-  }
+export async function sessionLoad({ name, gentleMode, discardBackgroundTabs = false, lazy = false, eagerTabs = 10, __job } = {}) {
+  return runLargeOperation("session.load", async () => {
+    const sessions = await getSessions();
+    const session = sessions[name];
+    if (!session) throw new Error(`Session '${name}' not found`);
 
-  const groups = new Map();
-  for (const { tabId, entry } of createdTabs) {
-    if (!entry.group) continue;
-    const key = entry.group.key || `${entry.group.title || "group"}:${groups.size}`;
-    if (!groups.has(key)) {
-      groups.set(key, { meta: entry.group, tabIds: [] });
+    const sessionTabs = getSessionTabs(session).sort((a, b) => Number(Boolean(b.pinned)) - Number(Boolean(a.pinned)));
+    const createdTabs = [];
+    const throttle = await getLargeOperationThrottle(sessionTabs.length, gentleMode);
+    const createBatchSize = Math.max(1, Math.min(10, throttle.batchSize));
+    const eagerLimit = lazy ? Math.max(0, Number(eagerTabs) || 0) : sessionTabs.length;
+    const { lazySessionTabs } = await chrome.storage.local.get("lazySessionTabs");
+    const lazyMap = lazySessionTabs || {};
+    updateJobProgress(__job, { phase: "opening", current: 0, total: sessionTabs.length });
+
+    for (const [idx, entry] of sessionTabs.entries()) {
+      throwIfJobCancelled(__job);
+      const shouldLazy = lazy && idx >= eagerLimit;
+      const tab = await chrome.tabs.create({ url: shouldLazy ? lazyPlaceholderUrl(entry.url) : entry.url, active: false, pinned: Boolean(entry.pinned) });
+      createdTabs.push({ tabId: tab.id, entry });
+      if (shouldLazy) {
+        lazyMap[String(tab.id)] = { url: entry.url, createdAt: Date.now() };
+      } else if (discardBackgroundTabs && !entry.pinned && chrome.tabs.discard) {
+        try { await chrome.tabs.discard(tab.id); } catch (_) {}
+      }
+      updateJobProgress(__job, { phase: shouldLazy ? "creating lazy placeholders" : "opening", current: createdTabs.length, total: sessionTabs.length });
+      await yieldForLargeOperation(createdTabs.length, createBatchSize, Math.max(50, throttle.pauseMs));
     }
-    groups.get(key).tabIds.push(tabId);
-  }
+    if (lazy) await chrome.storage.local.set({ lazySessionTabs: lazyMap });
 
-  for (const { meta, tabIds } of groups.values()) {
-    const restoredGroupId = await chrome.tabs.group({ tabIds });
-    await chrome.tabGroups.update(restoredGroupId, {
-      title: meta.title || "",
-      color: normalizeGroupColor(meta.color),
-      collapsed: Boolean(meta.collapsed),
-    });
-  }
+    const groups = new Map();
+    for (const { tabId, entry } of createdTabs) {
+      if (!entry.group) continue;
+      const key = entry.group.key || `${entry.group.title || "group"}:${groups.size}`;
+      if (!groups.has(key)) {
+        groups.set(key, { meta: entry.group, tabIds: [] });
+      }
+      groups.get(key).tabIds.push(tabId);
+    }
 
-  return { name, tabs: sessionTabs.length };
+    let restoredGroups = 0;
+    updateJobProgress(__job, { phase: "restoring groups", current: 0, total: groups.size });
+    for (const { meta, tabIds } of groups.values()) {
+      throwIfJobCancelled(__job);
+      const restoredGroupId = await chrome.tabs.group({ tabIds });
+      await chrome.tabGroups.update(restoredGroupId, {
+        title: meta.title || "",
+        color: normalizeGroupColor(meta.color),
+        collapsed: Boolean(meta.collapsed),
+      });
+      restoredGroups++;
+      updateJobProgress(__job, { phase: "restoring groups", current: restoredGroups, total: groups.size });
+      await yieldForLargeOperation(restoredGroups, 5, Math.max(50, throttle.pauseMs));
+    }
+
+    return { name, tabs: sessionTabs.length, gentle: throttle.gentle, audible: throttle.audible, discarded: Boolean(discardBackgroundTabs), lazy: Boolean(lazy), eagerTabs: eagerLimit };
+  });
 }
 
 export async function sessionList() {
@@ -92,21 +153,86 @@ export async function sessionDiff({ nameA, nameB }) {
   };
 }
 
+let autoSaveTimer = null;
+let autoSaveInFlight = false;
+let autoSavePending = false;
+
 export async function sessionAutoSave({ enabled }) {
   await chrome.storage.local.set({ autoSave: enabled });
-  chrome.tabs.onUpdated.removeListener(autoSaveHandler);
+  chrome.tabs.onCreated.removeListener(autoSaveHandler);
   chrome.tabs.onRemoved.removeListener(autoSaveHandler);
+  chrome.tabs.onMoved.removeListener(autoSaveHandler);
+  chrome.tabs.onAttached.removeListener(autoSaveHandler);
+  chrome.tabs.onDetached.removeListener(autoSaveHandler);
+  chrome.tabs.onUpdated.removeListener(autoSaveUpdatedHandler);
+  if (chrome.tabGroups?.onUpdated) chrome.tabGroups.onUpdated.removeListener(autoSaveHandler);
+  if (autoSaveTimer) clearTimeout(autoSaveTimer);
+  autoSaveTimer = null;
+  autoSavePending = false;
   if (enabled) {
-    chrome.tabs.onUpdated.addListener(autoSaveHandler);
+    chrome.tabs.onCreated.addListener(autoSaveHandler);
     chrome.tabs.onRemoved.addListener(autoSaveHandler);
+    chrome.tabs.onMoved.addListener(autoSaveHandler);
+    chrome.tabs.onAttached.addListener(autoSaveHandler);
+    chrome.tabs.onDetached.addListener(autoSaveHandler);
+    chrome.tabs.onUpdated.addListener(autoSaveUpdatedHandler);
+    if (chrome.tabGroups?.onUpdated) chrome.tabGroups.onUpdated.addListener(autoSaveHandler);
   }
   return { enabled };
 }
 
-export async function autoSaveHandler() {
+async function saveAutoSessionIfChanged() {
+  const tabs = await chrome.tabs.query({});
+  const groups = await chrome.tabGroups.query({});
+  const sessionTabs = buildSessionSnapshot(tabs, groups);
+  const signature = sessionSignature(sessionTabs);
+  const { autoSaveSignature } = await chrome.storage.local.get("autoSaveSignature");
+  if (autoSaveSignature === signature) return { skipped: true, tabs: sessionTabs.length };
+
+  const sessions = await getSessions();
+  sessions.__auto__ = {
+    tabs: sessionTabs,
+    urls: sessionTabs.map(tab => tab.url),
+    savedAt: Date.now(),
+    signature,
+  };
+  await chrome.storage.local.set({ sessions, autoSaveSignature: signature });
+  return { skipped: false, tabs: sessionTabs.length };
+}
+
+async function runAutoSave() {
+  if (autoSaveInFlight) {
+    autoSavePending = true;
+    return;
+  }
+  autoSaveInFlight = true;
+  try {
+    const { autoSave } = await chrome.storage.local.get("autoSave");
+    if (autoSave) await runLargeOperation("session.auto_save", saveAutoSessionIfChanged);
+  } finally {
+    autoSaveInFlight = false;
+    if (autoSavePending) {
+      autoSavePending = false;
+      autoSaveTimer = setTimeout(runAutoSave, 1000);
+    }
+  }
+}
+
+async function scheduleAutoSave(delayMs = 1000) {
   const { autoSave } = await chrome.storage.local.get("autoSave");
   if (!autoSave) return;
-  await sessionSave({ name: "__auto__" });
+  if (autoSaveTimer) clearTimeout(autoSaveTimer);
+  autoSaveTimer = setTimeout(runAutoSave, delayMs);
+}
+
+export async function autoSaveHandler() {
+  await scheduleAutoSave();
+}
+
+export async function autoSaveUpdatedHandler(_tabId, changeInfo = {}) {
+  // Ignore noisy media/title/favicon/loading updates. Sessions only store URL and group/window structure.
+  if (!("url" in changeInfo)) return;
+  await scheduleAutoSave();
 }
 
 // ── Misc ──────────────────────────────────────────────────────────────────────

extension/src/commands/tabs.ts

@@ -1,5 +1,5 @@
 // @ts-nocheck
-import { executeScript, getActiveTab, getAliases, isBrowserErrorUrl, isErrorPageScriptError, isScriptableUrl, resolveTabForDirectAction, tabInfo } from '../core';
+import { executeScript, getActiveTab, getAliases, getLargeOperationThrottle, isBrowserErrorUrl, isErrorPageScriptError, isScriptableUrl, resolveTabForDirectAction, runLargeOperation, tabInfo, throwIfJobCancelled, updateJobProgress, yieldForLargeOperation } from '../core';
 export async function tabsList() {
   const windows = await chrome.windows.getAll({ populate: true });
   const aliases = await getAliases();
@@ -17,24 +17,33 @@ export async function tabsList() {
   return tabs;
 }
 
-export async function tabsClose({ tabId, inactive, duplicates }) {
-  let toClose = [];
-  if (duplicates) {
-    const all = await chrome.tabs.query({});
-    const seen = new Set();
-    for (const t of all) {
-      if (!t.url) continue;
-      if (seen.has(t.url)) toClose.push(t.id);
-      else seen.add(t.url);
+export async function tabsClose({ tabId, inactive, duplicates, gentleMode, __job } = {}) {
+  return runLargeOperation("tabs.close", async () => {
+    let toClose = [];
+    if (duplicates) {
+      const all = await chrome.tabs.query({});
+      const seen = new Set();
+      for (const t of all) {
+        if (!t.url) continue;
+        if (seen.has(t.url)) toClose.push(t.id);
+        else seen.add(t.url);
+      }
+    } else if (inactive) {
+      const all = await chrome.tabs.query({});
+      toClose = all.filter(t => !t.active).map(t => t.id);
+    } else if (tabId) {
+      toClose = [tabId];
     }
-  } else if (inactive) {
-    const all = await chrome.tabs.query({});
-    toClose = all.filter(t => !t.active).map(t => t.id);
-  } else if (tabId) {
-    toClose = [tabId];
-  }
-  if (toClose.length) await chrome.tabs.remove(toClose);
-  return { closed: toClose.length };
+    const throttle = await getLargeOperationThrottle(toClose.length, gentleMode);
+    updateJobProgress(__job, { phase: "closing tabs", current: 0, total: toClose.length });
+    for (let i = 0; i < toClose.length; i += throttle.batchSize) {
+      throwIfJobCancelled(__job);
+      await chrome.tabs.remove(toClose.slice(i, i + throttle.batchSize));
+      updateJobProgress(__job, { phase: "closing tabs", current: Math.min(i + throttle.batchSize, toClose.length), total: toClose.length });
+      await yieldForLargeOperation(i + throttle.batchSize, throttle.batchSize, throttle.pauseMs);
+    }
+    return { closed: toClose.length, gentle: throttle.gentle, audible: throttle.audible };
+  });
 }
 
 export async function tabsMove({ tabId, groupId, windowId, index, forward, backward }) {
@@ -127,41 +136,62 @@ export async function tabsHtml({ tabId }) {
   }
 }
 
-export async function tabsDedupe() {
-  return tabsClose({ duplicates: true });
+export async function tabsDedupe(args = {}) {
+  return tabsClose({ ...args, duplicates: true });
 }
 
-export async function tabsSort({ by }) {
-  const windows = await chrome.windows.getAll({ populate: true });
-  let moved = 0;
-  for (const w of windows) {
-    const sorted = [...w.tabs].sort((a, b) => {
-      if (by === "title") return (a.title || "").localeCompare(b.title || "");
-      if (by === "time")  return a.id - b.id; // lower id = opened earlier
-      // domain (default)
-      const da = new URL(a.url || a.pendingUrl || "about:blank").hostname;
-      const db = new URL(b.url || b.pendingUrl || "about:blank").hostname;
-      return da.localeCompare(db);
-    });
-    for (let i = 0; i < sorted.length; i++) {
-      await chrome.tabs.move(sorted[i].id, { index: i });
-      moved++;
+export async function tabsSort({ by, gentleMode, __job } = {}) {
+  return runLargeOperation("tabs.sort", async () => {
+    const windows = await chrome.windows.getAll({ populate: true });
+    let moved = 0;
+    const totalTabs = windows.reduce((sum, w) => sum + (w.tabs?.length || 0), 0);
+    updateJobProgress(__job, { phase: "sorting tabs", current: 0, total: totalTabs });
+    for (const w of windows) {
+      const sorted = [...w.tabs].sort((a, b) => {
+        if (by === "title") return (a.title || "").localeCompare(b.title || "");
+        if (by === "time")  return a.id - b.id; // lower id = opened earlier
+        // domain (default)
+        const da = new URL(a.url || a.pendingUrl || "about:blank").hostname;
+        const db = new URL(b.url || b.pendingUrl || "about:blank").hostname;
+        return da.localeCompare(db);
+      });
+      if (w.tabs.every((tab, index) => tab.id === sorted[index]?.id)) continue;
+      const throttle = await getLargeOperationThrottle(sorted.length, gentleMode);
+      const moveBatchSize = Math.max(1, Math.min(10, throttle.batchSize));
+      for (let i = 0; i < sorted.length; i++) {
+        throwIfJobCancelled(__job);
+        await chrome.tabs.move(sorted[i].id, { index: i });
+        moved++;
+        updateJobProgress(__job, { phase: "sorting tabs", current: moved, total: totalTabs });
+        await yieldForLargeOperation(moved, moveBatchSize, throttle.pauseMs);
+      }
     }
-  }
-  return { moved };
+    return { moved };
+  });
 }
 
-export async function tabsMergeWindows() {
-  const current = await chrome.windows.getCurrent();
-  const all = await chrome.windows.getAll({ populate: true });
-  let moved = 0;
-  for (const w of all) {
-    if (w.id === current.id) continue;
-    const ids = w.tabs.map(t => t.id);
-    await chrome.tabs.move(ids, { windowId: current.id, index: -1 });
-    moved += ids.length;
-  }
-  return { moved };
+export async function tabsMergeWindows({ gentleMode, __job } = {}) {
+  return runLargeOperation("tabs.merge_windows", async () => {
+    const current = await chrome.windows.getCurrent();
+    const all = await chrome.windows.getAll({ populate: true });
+    let moved = 0;
+    const totalTabs = all.filter(w => w.id !== current.id).reduce((sum, w) => sum + (w.tabs?.length || 0), 0);
+    updateJobProgress(__job, { phase: "merging windows", current: 0, total: totalTabs });
+    for (const w of all) {
+      if (w.id === current.id) continue;
+      const ids = w.tabs.map(t => t.id);
+      const throttle = await getLargeOperationThrottle(ids.length, gentleMode);
+      for (let i = 0; i < ids.length; i += throttle.batchSize) {
+        throwIfJobCancelled(__job);
+        const chunk = ids.slice(i, i + throttle.batchSize);
+        await chrome.tabs.move(chunk, { windowId: current.id, index: -1 });
+        moved += chunk.length;
+        updateJobProgress(__job, { phase: "merging windows", current: moved, total: totalTabs });
+        await yieldForLargeOperation(moved, throttle.batchSize, throttle.pauseMs);
+      }
+    }
+    return { moved };
+  });
 }
 
 export async function tabsPin({ tabId }) {

extension/src/core.ts

@@ -32,13 +32,94 @@ export function isTransientScriptError(error) {
   return message.includes("Frame with ID") || message.includes("No tab with id") || isErrorPageScriptError(error);
 }
 
+export function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export const LARGE_OPERATION_BATCH_SIZE = 25;
+export const LARGE_OPERATION_PAUSE_MS = 25;
+export const GENTLE_OPERATION_BATCH_SIZE = 8;
+export const GENTLE_OPERATION_PAUSE_MS = 100;
+
+export async function hasAudibleTabs() {
+  const audibleTabs = await chrome.tabs.query({ audible: true });
+  return audibleTabs.some(tab => !(tab.mutedInfo && tab.mutedInfo.muted));
+}
+
+let largeOperationQueue = Promise.resolve();
+
+export async function runLargeOperation(name, fn) {
+  const run = largeOperationQueue.then(async () => {
+    console.log(`[browser-cli] large operation start: ${name}`);
+    try {
+      return await fn();
+    } finally {
+      console.log(`[browser-cli] large operation done: ${name}`);
+    }
+  });
+  largeOperationQueue = run.catch(() => {});
+  return run;
+}
+
+export async function getPerformanceProfile() {
+  const { performanceProfile } = await chrome.storage.local.get("performanceProfile");
+  return performanceProfile || "auto";
+}
+
+export async function setPerformanceProfile(profile) {
+  const allowed = new Set(["auto", "normal", "gentle", "ultra"]);
+  const performanceProfile = allowed.has(profile) ? profile : "auto";
+  await chrome.storage.local.set({ performanceProfile });
+  return { performanceProfile };
+}
+
+export async function getLargeOperationThrottle(itemCount = 0, mode = "auto") {
+  const audible = await hasAudibleTabs();
+  const storedProfile = await getPerformanceProfile();
+  const configuredMode = mode && mode !== "auto" ? mode : storedProfile;
+  const gentle = configuredMode === "gentle" || configuredMode === "ultra" || (configuredMode === "auto" && audible);
+  let batchSize = gentle ? GENTLE_OPERATION_BATCH_SIZE : LARGE_OPERATION_BATCH_SIZE;
+  let pauseMs = gentle ? GENTLE_OPERATION_PAUSE_MS : LARGE_OPERATION_PAUSE_MS;
+
+  if (configuredMode === "ultra" || itemCount >= 300) {
+    batchSize = Math.max(3, Math.floor(batchSize / 2));
+    pauseMs *= 2;
+  } else if (itemCount >= 100) {
+    batchSize = Math.max(5, Math.floor(batchSize * 0.75));
+    pauseMs = Math.max(pauseMs, 75);
+  }
+
+  return { batchSize, pauseMs, gentle, audible, itemCount, mode: configuredMode };
+}
+
+export function updateJobProgress(job, { phase, current, total } = {}) {
+  if (!job) return;
+  if (phase) job.phase = phase;
+  if (total != null) job.total = total;
+  if (current != null) job.current = current;
+  if (job.total) job.percent = Math.min(100, Math.round((job.current || 0) * 100 / job.total));
+  job.updatedAt = Date.now();
+}
+
+export function throwIfJobCancelled(job) {
+  if (job?.cancelRequested) {
+    throw new Error(`Job '${job.id}' cancelled`);
+  }
+}
+
+export async function yieldForLargeOperation(processed, batchSize = LARGE_OPERATION_BATCH_SIZE, pauseMs = LARGE_OPERATION_PAUSE_MS) {
+  if (processed > 0 && processed % batchSize === 0) {
+    await sleep(pauseMs);
+  }
+}
+
 export async function executeScript(options, retries = 3) {
   for (let i = 0; i < retries; i++) {
     try {
       return await chrome.scripting.executeScript(options);
     } catch (e) {
       if (i < retries - 1 && isTransientScriptError(e)) {
-        await new Promise(r => setTimeout(r, 300));
+        await sleep(300);
         continue;
       }
       throw e;
@@ -52,8 +133,9 @@ export function tabInfo(t) {
     windowId: t.windowId,
     active: t.active,
     muted: Boolean(t.mutedInfo && t.mutedInfo.muted),
+    groupId: t.groupId >= 0 ? t.groupId : null,
     title: t.title,
-    url: t.url,
+    url: t.url || t.pendingUrl || "",
   };
 }
 

extension/src/index.ts

@@ -5,7 +5,7 @@
  * Connects to the native host (com.browsercli.host) via Native Messaging.
  */
 
-import { getProfileAlias } from './core';
+import { getLargeOperationThrottle, getPerformanceProfile, hasAudibleTabs, setPerformanceProfile, getProfileAlias } from './core';
 import * as nav from './commands/navigation';
 import * as tabs from './commands/tabs';
 import * as groups from './commands/groups';
@@ -17,6 +17,15 @@ import * as session from './commands/session';
 const NATIVE_HOST = "com.browsercli.host";
 let port = null;
 let keepaliveEnabled = true;
+const jobs = new Map();
+const BACKGROUND_COMMANDS = new Set([
+  "session.load",
+  "tabs.close",
+  "tabs.dedupe",
+  "tabs.sort",
+  "tabs.merge_windows",
+  "group.close",
+]);
 
 // ── Connection management ─────────────────────────────────────────────────────
 function sendControlMessage(targetPort, message) {
@@ -88,6 +97,10 @@ chrome.alarms.onAlarm.addListener((alarm) => {
   }
 });
 
+chrome.tabs.onActivated.addListener(async ({ tabId }) => {
+  await session.activateLazyTab(tabId);
+});
+
 // ── Message dispatcher ────────────────────────────────────────────────────────
 
 async function onMessage(msg) {
@@ -98,10 +111,14 @@ async function onMessage(msg) {
 
   let data, error;
   try {
-    const { __page, ...commandArgs } = args || {};
-    data = await dispatch(command, commandArgs);
-    if (__page && Array.isArray(data)) {
-      data = makePagedData(data, __page);
+    const { __page, __background, ...commandArgs } = args || {};
+    if (__background && BACKGROUND_COMMANDS.has(command)) {
+      data = await startBackgroundJob(command, commandArgs);
+    } else {
+      data = await dispatch(command, commandArgs);
+      if (__page && Array.isArray(data)) {
+        data = makePagedData(data, __page);
+      }
     }
   } catch (e) {
     error = e.message || String(e);
@@ -121,6 +138,94 @@ async function onMessage(msg) {
     await connect();
   }
 }
+async function persistJobs() {
+  const recentJobs = [...jobs.values()].slice(-50).map(job => ({ ...job, __timer: undefined }));
+  await chrome.storage.local.set({ recentJobs });
+}
+
+async function startBackgroundJob(command, args) {
+  const jobId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+  const job = {
+    id: jobId,
+    command,
+    status: "running",
+    phase: "queued",
+    current: 0,
+    total: null,
+    percent: 0,
+    cancelRequested: false,
+    startedAt: Date.now(),
+    updatedAt: Date.now(),
+    finishedAt: null,
+    result: null,
+    error: null,
+  };
+  jobs.set(jobId, job);
+  job.__timer = setInterval(persistJobs, 1000);
+  await persistJobs();
+  dispatch(command, { ...args, __job: job })
+    .then(async result => {
+      job.status = "done";
+      job.phase = "done";
+      job.result = result;
+      job.current = job.total || job.current;
+      job.percent = 100;
+      job.finishedAt = Date.now();
+      job.updatedAt = Date.now();
+      if (job.__timer) clearInterval(job.__timer);
+      await persistJobs();
+    })
+    .catch(async error => {
+      job.status = job.cancelRequested ? "cancelled" : "error";
+      job.phase = job.status;
+      job.error = error?.message || String(error);
+      job.finishedAt = Date.now();
+      job.updatedAt = Date.now();
+      if (job.__timer) clearInterval(job.__timer);
+      await persistJobs();
+    });
+  return { jobId, command, status: job.status };
+}
+
+async function jobStatus({ jobId }) {
+  const job = jobs.get(jobId);
+  if (job) return { ...job };
+  const { recentJobs } = await chrome.storage.local.get("recentJobs");
+  const stored = (recentJobs || []).find(entry => entry.id === jobId);
+  if (!stored) throw new Error(`Job '${jobId}' not found`);
+  return stored;
+}
+
+async function jobCancel({ jobId }) {
+  const job = jobs.get(jobId);
+  if (!job) throw new Error(`Job '${jobId}' not running`);
+  job.cancelRequested = true;
+  job.updatedAt = Date.now();
+  await persistJobs();
+  return { jobId, cancelled: true };
+}
+
+async function perfStatus() {
+  const profile = await getPerformanceProfile();
+  const audible = await hasAudibleTabs();
+  const throttle = await getLargeOperationThrottle(0, "auto");
+  return {
+    performanceProfile: profile,
+    audible,
+    throttle,
+    jobs: [...jobs.values()].map(job => ({
+      id: job.id,
+      command: job.command,
+      status: job.status,
+      phase: job.phase,
+      current: job.current,
+      total: job.total,
+      percent: job.percent,
+      cancelRequested: job.cancelRequested,
+    })),
+  };
+}
+
 function makePagedData(items, page) {
   const total = items.length;
   const offset = Math.max(0, Number(page.offset) || 0);
@@ -160,9 +265,9 @@ async function dispatch(command, args) {
     case "tabs.count":        return tabs.tabsCount(args);
     case "tabs.query":        return tabs.tabsQuery(args);
     case "tabs.html":         return tabs.tabsHtml(args);
-    case "tabs.dedupe":       return tabs.tabsDedupe();
+    case "tabs.dedupe":       return tabs.tabsDedupe(args);
     case "tabs.sort":         return tabs.tabsSort(args);
-    case "tabs.merge_windows": return tabs.tabsMergeWindows();
+    case "tabs.merge_windows": return tabs.tabsMergeWindows(args);
     case "tabs.mute":         return tabs.tabsMute(args);
     case "tabs.unmute":       return tabs.tabsUnmute(args);
     case "tabs.pin":          return tabs.tabsPin(args);
@@ -234,6 +339,20 @@ async function dispatch(command, args) {
     case "session.diff":      return session.sessionDiff(args);
     case "session.auto_save": return session.sessionAutoSave(args);
 
+    // ── Jobs ──────────────────────────────────────────────────────────────
+    case "jobs.status": return jobStatus(args);
+    case "jobs.cancel": return jobCancel(args);
+
+    // ── Performance ───────────────────────────────────────────────────────
+    case "perf.status": return perfStatus();
+    case "perf.set_profile": return setPerformanceProfile(args.profile);
+
+    // ── Extension ─────────────────────────────────────────────────────────
+    case "extension.reload": {
+      setTimeout(() => chrome.runtime.reload(), 200);
+      return { reloading: true };
+    }
+
     // ── Misc ──────────────────────────────────────────────────────────────
     case "clients.list":           return session.clientsList();
     case "clients.rename_profile": return session.clientsRenameProfile(args);