refactor(extension): class-based command registry + modular src layout

Restructure the MV3 background worker from a monolithic core.ts/index.ts
into a class-based command architecture. Behavior is identical — the 83
registered commands dispatch byte-for-byte the same as before.

Structure
- One class per command group, each extending CommandGroup and exporting a
  `commands` map keyed by the full command id ("tabs.close"). Groups:
  Navigation, TabsMutation, TabsQuery, Groups, Windows, Dom (dom/extract/
  page), BrowserData (storage/cookies), Session (session/clients + autosave
  + lazy-tab activation), Perf (perf + jobs.status/cancel), Extension.
- CommandRegistry merges the group maps (throws on duplicate ids), routes
  background specs to JobManager and paginates array results via
  makePagedData. JobManager owns the job map + lifecycle. NativeConnection
  owns the native-port lifecycle and the inbound message router.
- index.ts is now thin wiring: JobManager -> ctx -> assembleRegistry ->
  onActivated -> NativeConnection.start().
- Infra classes live in classes/ (PascalCase, file = class name); command
  groups in commands/; shared helpers split out of core.ts into core/
  (errors, throttle, scripting, tab-helpers, group-helpers, storage); all
  types moved into types/ (json, jobs, session, tabs, messages,
  command-args) behind a barrel.

DRY cleanup
- resolveTabUrl(tabId) and assertScriptableUrl(url, action) collapse the
  tab/URL-guard boilerplate duplicated across dom.ts and browser-data.ts.
- processInBatches() centralizes the throttled, cancellable batch loop
  shared by tabs.close, group.close and tabs.merge_windows.
- captureCurrentSession() dedups the snapshot-and-signature block shared by
  session.save and the autosave path.
- DomArgs type alias replaces 21 inline ContentArgs & { tabId? } copies.
- Drop fetchTabHtml's redundant retry loop (executeScript already retries
  transient frame/tab errors), a dead tabInfo import, and two stale
  comments referencing a removed asArgs helper.

Type safety & tests
- Full noImplicitAny; no `any`/`unknown` annotations remain in src.
- JS unit-test harness using node --test + node:assert (zero new deps),
  bundled via the existing esbuild. Covers JobManager retention/lifecycle
  and the autosave listener-wiring/debounce with an in-memory chrome mock.
- The structural pytest checks track the new file homes and the centralized
  processInBatches helper.

Verification: npm run check:extension green (tsc + esbuild 84.5kb +
node --check + 18 JS tests); uv run pytest -q -> 409 passed, 105 skipped.
No version bump.

extension/src/commands/tabs-query.ts

@@ -0,0 +1,95 @@
+import { fetchTabHtml, getActiveTab, getAliases, isBrowserErrorUrl, tabInfo } from '../core';
+import { CommandGroup } from '../classes/CommandGroup';
+import type { CommandEntry } from '../classes/CommandGroup';
+import type { TabIdArgs, TabsActiveInWindowArgs, TabsPatternArgs, TabsQueryArgs, TabsWatchUrlArgs } from '../types';
+
+export class TabsQueryCommands extends CommandGroup {
+  readonly namespace = "tabs";
+  readonly commands: Record<string, CommandEntry> = {
+    "tabs.list":             () => this.tabsList(),
+    "tabs.active_in_window": (a: TabsActiveInWindowArgs) => this.tabsActiveInWindow(a),
+    "tabs.status":           (a: TabIdArgs) => this.tabsStatus(a),
+    "tabs.filter":           (a: TabsPatternArgs) => this.tabsFilter(a),
+    "tabs.count":            (a: TabsPatternArgs) => this.tabsCount(a),
+    "tabs.query":            (a: TabsQueryArgs) => this.tabsQuery(a),
+    "tabs.html":             (a: TabIdArgs) => fetchTabHtml(a.tabId),
+    "tabs.watch_url":        (a: TabsWatchUrlArgs) => this.tabsWatchUrl(a),
+  };
+
+  private async tabsList() {
+    const windows = await chrome.windows.getAll({ populate: true });
+    const aliases = await getAliases();
+    const tabs = [];
+    for (const w of windows) {
+      for (const t of w.tabs) {
+        tabs.push({
+          ...tabInfo(t),
+          windowAlias: aliases[t.windowId] || null,
+          pinned: t.pinned,
+          favIconUrl: t.favIconUrl,
+        });
+      }
+    }
+    return tabs;
+  }
+
+  private async tabsActiveInWindow({ windowId }: TabsActiveInWindowArgs) {
+    const activeTabs = await chrome.tabs.query({ windowId, active: true });
+    const tab = activeTabs[0];
+    if (!tab) {
+      throw new Error(`No active tab found for window ${windowId}`);
+    }
+    return tabInfo(tab);
+  }
+
+  private async tabsStatus({ tabId }: TabIdArgs) {
+    const tab = tabId ? await chrome.tabs.get(tabId) : await getActiveTab();
+    return tabInfo(tab);
+  }
+
+  private async tabsFilter({ pattern }: TabsPatternArgs) {
+    const all = await chrome.tabs.query({});
+    return all.filter(t => t.url && t.url.includes(pattern)).map(tabInfo);
+  }
+
+  private async tabsCount({ pattern }: TabsPatternArgs) {
+    const all = await chrome.tabs.query({});
+    if (pattern) return all.filter(t => t.url && t.url.includes(pattern)).length;
+    return all.length;
+  }
+
+  private async tabsQuery({ search }: TabsQueryArgs) {
+    const q = search.toLowerCase();
+    const all = await chrome.tabs.query({});
+    return all.filter(t =>
+      (t.url && t.url.toLowerCase().includes(q)) ||
+      (t.title && t.title.toLowerCase().includes(q))
+    ).map(tabInfo);
+  }
+
+  private async tabsWatchUrl({ pattern, timeout = 30000, tabId }: TabsWatchUrlArgs = {}) {
+    const tab = tabId ? await chrome.tabs.get(tabId) : await getActiveTab();
+    const deadline = Date.now() + timeout;
+    const regex = new RegExp(pattern);
+    let lastUrl = tab.url || tab.pendingUrl || "";
+    let lastStatus = tab.status || "unknown";
+
+    const matches = (url: string) => {
+      regex.lastIndex = 0;
+      return Boolean(url && regex.test(url));
+    };
+    if (matches(lastUrl)) return tabInfo(tab);
+
+    while (Date.now() < deadline) {
+      const t = await chrome.tabs.get(tab.id);
+      lastUrl = t.url || t.pendingUrl || "";
+      lastStatus = t.status || "unknown";
+      if (matches(t.pendingUrl || "") || matches(t.url || "")) return tabInfo(t);
+      if (isBrowserErrorUrl(t.url || "")) {
+        throw new Error(`Tab ${tab.id} is showing an error page while waiting for URL to match '${pattern}'`);
+      }
+      await new Promise(r => setTimeout(r, 200));
+    }
+    throw new Error(`Tab ${tab.id} URL did not match '${pattern}' within ${timeout}ms (last URL: '${lastUrl}', status: '${lastStatus}')`);
+  }
+}