commit f8e781f0e98688607d4c5c5085ed65810b970aca
Author: admin <admin@eswiig.com>
Date:   Fri May 22 21:05:21 2026 +0200

    Initial snapshot before step 6 options.js split

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..e0af246
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,3 @@
+host/__pycache__/
+host/logs/
+host/state/
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..3687a6a
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,169 @@
+# rclone-jav (Brave extension + native messaging host)
+
+Session memory for Claude. Read before making changes here.
+
+## Architecture
+
+```
+Brave tab title -> content script extracts JAV ID
+                -> background.js connectNative("com.rcjav.host")
+                -> host/rcjav-host.bat (portable: py launcher or python on PATH)
+                -> host/rcjav-host.py
+                -> subprocess python rc-jav.py --search ID --basic --no-color --format json
+                -> structured hits back through native port
+                -> popup or in-page overlay
+```
+
+Two separate codebases:
+- This repo: Brave extension + native messaging host.
+- `D:\DEV\Project\rclone-jav\` — Python rc-jav CLI. The host shells out to `rc-jav.py` here.
+
+## Folder layout (post-rename)
+
+```
+D:\DEV\Extensions\Production\rclone-jav\   (PC 1)
+D:\DEV\Extensions\Staging\rclone-jav\      (PC 2)
+├── manifest.json
+├── background.js
+├── content.js
+├── popup.{html,js,css}
+├── options.{html,js}
+├── host\
+│   ├── rcjav-host.py
+│   ├── rcjav-host.bat       (portable: py launcher fallback)
+│   ├── install-host.ps1     (self-elevates to HKLM)
+│   ├── register-host.bat    (prompts for ID, calls install-host.ps1)
+│   ├── com.rcjav.host.json  (generated; UTF-8 NO BOM)
+│   └── (logs)
+└── docs\
+    ├── INSTALL.md           (gotcha table at the bottom)
+    └── README.md
+```
+
+## Critical gotchas (learned the hard way)
+
+| Symptom | Cause | Fix |
+|---|---|---|
+| "Specified native messaging host not found" | UTF-8 BOM in com.rcjav.host.json | `WriteAllText` with `UTF8Encoding($false)` |
+| Same error after registering HKCU | Brave on Windows ignores HKCU on some installs | Register HKLM too. `install-host.ps1` does both. |
+| Host launches then disconnects | Python text-mode stdio mangles 4-byte length prefix | `msvcrt.setmode(stdin/stdout, O_BINARY)` at host startup |
+| Host log says "stdin closed, exiting" immediately | bat-side stderr leak corrupts protocol | `python -u` + redirect stderr to log file |
+| `Missing closing '}'` in install-host.ps1 | Em-dashes in comments + LF endings + Windows PS 5.1 (cp1252 fallback) | Strip em-dashes from .ps1 files, or save with BOM, or use pwsh |
+| Brave reload != Brave restart | NM cache survives extension reload | Kill all brave.exe processes then reopen |
+| `IBW-902z` page title fails to parse | `\b` after `\d` blocked by following word char | Extension regex uses `[a-zA-Z]?\b` trailing — captured but discarded |
+| Delete safety too broad | Allowlist reduced `cq:JAV` to `cq:` | Match full configured prefixes, not remote roots |
+| Overlay feels ~1.5s late on SPA pages | `SPA_SETTLE_MS` waits before auto-check | Current value is 800ms; tune carefully if detection gets flaky |
+
+## Internal names — keep as-is
+
+- Native messaging host: `com.rcjav.host` (NOT renamed despite extension rename)
+- Window flag in content.js: `__rclonex_loaded__` (idempotency guard for content script re-injection)
+- CSS IDs starting with `rclonex-` (overlay)
+- Host logs: `host/logs/rcjav-host.log`, `host/logs/rcjav-host-events.log`, `host/logs/rcjav-host-stderr.log`, `host/logs/deletes.log`
+- Host scan progress state: `host/state/scan-state.json`
+
+Don't rename these unless there's a real reason. They're orthogonal to the user-facing extension name.
+
+## Settings
+
+Stored in `chrome.storage.sync` under key `settings`. Per-extension-ID namespacing → if extension is reloaded under a different path, settings are wiped.
+
+**Backup/restore lives in Options → Setup & Transfer** — JSON export/import to survive reloads or PC migrations. Use it before renaming or relocating the extension.
+
+DEFAULT_SETTINGS lives in background.js. Keep in sync with options.html defaults.
+
+## Decision log
+
+### Deletion allowlist uses full prefixes (2026-05-20)
+
+**Decision:** host delete allowlist must use full configured path prefixes (`cq:JAV`, trash dir, etc.), not only remote roots like `cq:`.
+
+**Reasoning:** Reducing `cq:JAV` to `cq:` lets any path on the same rclone remote pass the safety check. Deletion is opt-in but must be tightly scoped.
+
+**Important:** extension delete calls must forward `rcjav_path`, or the host may read the wrong `config.json` and derive the wrong allowlist.
+
+### Toolbar popup setting gates auto-check (2026-05-20)
+
+**Decision:** `triggers.toolbarClick` does not remove the MV3 popup, but it does gate whether the popup auto-runs `checkTab` on open. If disabled, popup stays idle until user clicks Re-Scan.
+
+### Quick search and ID padding (2026-05-20)
+
+**Decision:** rc-jav canonical JAV IDs use at least 3 digits (`ABC-027`) and preserve 4+ digit IDs (`ABCD-1294`). Quick search emits canonical uppercase globs only.
+
+**Reasoning:** user clarified real JAV filenames are never `ABC-27` or `ABC-0027`; they are `ABC-027`. User also never uses lowercase filenames, so quick search should not use rclone `--ignore-case` because it added noticeable delay.
+
+**Operational note:** this changes cache keys. Run `python rc-jav.py --scan` in `D:\DEV\Project\rclone-jav` after this change.
+
+### No-match overlay metadata (2026-05-20)
+
+**Decision:** host search response includes `cache_meta` and `scanned_remotes` from rc-jav JSON so no-match overlays can show what was scanned instead of falling back to "library".
+
+### IBW-902z trailing letter (2026-05-20)
+
+**Decision:** minimal regex fix in extension only. NOT a full variant-suffix rewrite of the index.
+
+**Reasoning:** User's library uses one ID per number (either `IBW-902` OR `IBW-902z`, not both). Page titles failing on `IBW-902z` is the real bug. Extension regex now matches optional trailing letter and discards it. rc-jav's index continues to strip trailing letters at extract_id time. Effective: extension queries `IBW-902` for any title `IBW-902` or `IBW-902z`, finds the file regardless of how it's named on rclone.
+
+**Revisit if:** both `IBW-902.mp4` and `IBW-902z.mp4` ever coexist in library — they'd collide on the same ID. Then implement variant suffix (#var_Z) end-to-end.
+
+### Native messaging host name stayed `com.rcjav.host`
+
+When extension was renamed `rclonex` → `rclone-jav`, the NM host name was NOT renamed. Reason: zero user impact (it's an internal identifier in registry/manifest), but every rename costs registry rewrites + script churn. Not worth it.
+
+### WinCatalog backslash normalization
+
+Done in rc-jav catalog loading. Catalog CSV/XML paths are normalized from Windows `\` to rclone-style `/` before the extension sees them.
+
+## When making changes
+
+- Extension settings schema change → update `DEFAULT_SETTINGS` in background.js AND defaults in options.html + options.js load()
+- New native messaging action → handler in rcjav-host.py + DISPATCH map + extension code that sends it
+- New options pane → sidebar item in options.html + new `.pane` div + load/save bindings in options.js
+- Any rc-jav.py CLI change → host invocation in rcjav-host.py handle_search must keep pace
+
+---
+
+## Console consolidation refactor — execution status
+
+**Spec / blueprint:**
+- `D:\DEV\Project\rclone-jav\mockups\console-consolidation-claude.html` (refactor spec — decision table, sequence, acceptance criteria)
+- `D:\DEV\Project\rclone-jav\mockups\console-consolidation-options.html` (Codex's visual annotation variant)
+
+**Shipped (in execution order):**
+
+1. **Sim Dupe deleted from popup.** Button + click handler removed from `popup.html` / `popup.js`. Payload preserved in `samples/sim-dupe.js` for future layout work.
+2. **CSS extracted from options.html.** Embedded `<style>` block moved to `options.css`, linked via `<link rel="stylesheet">`. options.html went 1179 → 794 lines. Inline `style="..."` attributes intentionally left for later (step 6 territory).
+3. **Transfer Assistant wizard deleted.** "Setup & Transfer" pane renamed to "Setup". Replacement: Extension ID display + Copy button added to Diagnostics → Native host registration fieldset (always visible, not failure-gated). Sidebar entry, fieldset, modal, and ~107 lines of JS removed.
+5. **Recent Activity + Search Troubleshooting moved to new Debug Tools pane.** Verified Recent Activity is search-trigger-only by reading `background.js` — `recordActivity()` is NOT called from `delete-file` handler. No audit-value split needed. New sidebar entry "Debug Tools" under System group; new `pane-debug` houses both fieldsets.
+
+(Step 4 in the plan is a paired-extraction sub-task of step 6; not a separate ship.)
+
+**Pending (in execution order):**
+
+- **Step 6 — options.js split, Cache & Scans + Duplicate Review paired.** Biggest, riskiest step. `options.js` is currently 3133 lines. Pair these two together because Dup Review reads cache state — extracting one while the other stays in monolith creates cross-module gap. Continue with Debug Tools, Library Issues, Settings sub-tabs after the pair lands.
+- **Step 7a — Bulk Check standalone window.** New `bulk-check.html` opened as detached `chrome.windows.create({ type: 'popup', width: 640, height: 540 })` from a "Bulk Check" launcher button in the popup. Single canonical entry path — NOT a Console sidebar tab. Window dedup via `chrome.storage.session`, last-paste persisted via `chrome.storage.local`.
+- **Step 8 — Shared fixture corpus.** Top-level `D:\DEV\Project\rclone-jav\fixtures\` (neutral location, NOT inside Python or extension repo). JSON cases for query-ID extraction (extension), filename ID extraction (Python), shared normalization.
+- **Step 9 — Cache contract design.** CACHE_VERSION already exists (currently 3). Add ID_RULES_VERSION concept: schema bump = force rebuild, rules bump = warn-and-mark-stale.
+- **Step 10 — `rc-jav.py` module split** into `rcjav/` package (ids, cache, dupes, catalog, rclone_io, output, cli). Keep `rc-jav.py` as thin entrypoint that imports from `rcjav.cli.main`.
+- **Step 11 — Host fast-path benchmark and decide.** Measure popup search latency under (a) idle Python and (b) Python actively scanning. If host fast path is the only thing keeping popup responsive under scan = narrow to dict lookup only and document. If not needed = delete entirely.
+
+**Architecture (locked — do not relitigate):**
+
+- Sidebar = Console / Settings / Support tri-split. No dashboard pane. Status carried by badges on tab labels (`Duplicate Review [27]`, `Cache & Scans [28m]`, `Library Issues [4]`).
+- Default landing = Duplicate Review.
+- Bulk ID Check = detached `chrome.windows.create` popup, NOT a Console sidebar tab. Single canonical entry path = popup launcher button.
+- Keep Ranking Rules nested INSIDE Duplicate Review as a sub-tab, NOT a separate Settings tab.
+- Sim Dupe: deleted from extension. Repo HTML harness in `samples/` only.
+- Transfer Assistant: deleted. Diagnostics' Native host registration fieldset is the replacement (Extension ID copy + Repair Registration + Verify Registration buttons).
+- Vanilla JS + ordered `<script>` tags. No framework, no build system.
+- Inline rule tests stay next to rule editors (Matching Rules, Site Extraction). Standalone benches go to Debug Tools.
+
+**Notes:**
+
+- Repo is NOT git-initialized. Rollback for shipped steps = manual restore from this conversation's diffs. Worth running `git init` in this folder before step 6 (the big one) for safer iteration.
+- Three pre-execution handoffs from the original plan have been resolved:
+  - Recent Activity scope test → settled by code read (single role, all to Debug).
+  - Diagnostics replacement for Transfer wizard → present (Extension ID, Repair, Verify all visible in one fieldset).
+  - Popup launcher button label → defer until step 7a; text + emoji currently in mockup.
+
+If a future session wants to continue: read this status block + open the mockup HTML files for the full spec. Resume on step 6.
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..43c994c
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1 @@
+@AGENTS.md
diff --git a/CLAUDE.md.bak b/CLAUDE.md.bak
new file mode 100644
index 0000000..e6dd23e
--- /dev/null
+++ b/CLAUDE.md.bak
@@ -0,0 +1,122 @@
+# rclone-jav (Brave extension + native messaging host)
+
+Session memory for Claude. Read before making changes here.
+
+## Architecture
+
+```
+Brave tab title -> content script extracts JAV ID
+                -> background.js connectNative("com.rcjav.host")
+                -> host/rcjav-host.bat (portable: py launcher or python on PATH)
+                -> host/rcjav-host.py
+                -> subprocess python rc-jav.py --search ID --basic --no-color --format json
+                -> structured hits back through native port
+                -> popup or in-page overlay
+```
+
+Two separate codebases:
+- This repo: Brave extension + native messaging host.
+- `D:\DEV\Project\rclone-jav\` — Python rc-jav CLI. The host shells out to `rc-jav.py` here.
+
+## Folder layout (post-rename)
+
+```
+D:\DEV\Extensions\Production\rclone-jav\   (PC 1)
+D:\DEV\Extensions\Staging\rclone-jav\      (PC 2)
+├── manifest.json
+├── background.js
+├── content.js
+├── popup.{html,js,css}
+├── options.{html,js}
+├── host\
+│   ├── rcjav-host.py
+│   ├── rcjav-host.bat       (portable: py launcher fallback)
+│   ├── install-host.ps1     (self-elevates to HKLM)
+│   ├── register-host.bat    (prompts for ID, calls install-host.ps1)
+│   ├── com.rcjav.host.json  (generated; UTF-8 NO BOM)
+│   └── (logs)
+└── docs\
+    ├── INSTALL.md           (gotcha table at the bottom)
+    └── README.md
+```
+
+## Critical gotchas (learned the hard way)
+
+| Symptom | Cause | Fix |
+|---|---|---|
+| "Specified native messaging host not found" | UTF-8 BOM in com.rcjav.host.json | `WriteAllText` with `UTF8Encoding($false)` |
+| Same error after registering HKCU | Brave on Windows ignores HKCU on some installs | Register HKLM too. `install-host.ps1` does both. |
+| Host launches then disconnects | Python text-mode stdio mangles 4-byte length prefix | `msvcrt.setmode(stdin/stdout, O_BINARY)` at host startup |
+| Host log says "stdin closed, exiting" immediately | bat-side stderr leak corrupts protocol | `python -u` + redirect stderr to log file |
+| `Missing closing '}'` in install-host.ps1 | Em-dashes in comments + LF endings + Windows PS 5.1 (cp1252 fallback) | Strip em-dashes from .ps1 files, or save with BOM, or use pwsh |
+| Brave reload != Brave restart | NM cache survives extension reload | Kill all brave.exe processes then reopen |
+| `IBW-902z` page title fails to parse | `\b` after `\d` blocked by following word char | Extension regex uses `[a-zA-Z]?\b` trailing — captured but discarded |
+| Delete safety too broad | Allowlist reduced `cq:JAV` to `cq:` | Match full configured prefixes, not remote roots |
+| Overlay feels ~1.5s late on SPA pages | `SPA_SETTLE_MS` waits before auto-check | Current value is 800ms; tune carefully if detection gets flaky |
+
+## Internal names — keep as-is
+
+- Native messaging host: `com.rcjav.host` (NOT renamed despite extension rename)
+- Window flag in content.js: `__rclonex_loaded__` (idempotency guard for content script re-injection)
+- CSS IDs starting with `rclonex-` (overlay)
+- Host logs: `host/logs/rcjav-host.log`, `host/logs/rcjav-host-events.log`, `host/logs/rcjav-host-stderr.log`, `host/logs/deletes.log`
+- Host scan progress state: `host/state/scan-state.json`
+
+Don't rename these unless there's a real reason. They're orthogonal to the user-facing extension name.
+
+## Settings
+
+Stored in `chrome.storage.sync` under key `settings`. Per-extension-ID namespacing → if extension is reloaded under a different path, settings are wiped.
+
+**Backup/restore lives in Options → Paths → "Backup & restore"** — JSON export/import to survive reloads or PC migrations. Use it before renaming or relocating the extension.
+
+DEFAULT_SETTINGS lives in background.js. Keep in sync with options.html defaults.
+
+## Decision log
+
+### Deletion allowlist uses full prefixes (2026-05-20)
+
+**Decision:** host delete allowlist must use full configured path prefixes (`cq:JAV`, trash dir, etc.), not only remote roots like `cq:`.
+
+**Reasoning:** Reducing `cq:JAV` to `cq:` lets any path on the same rclone remote pass the safety check. Deletion is opt-in but must be tightly scoped.
+
+**Important:** extension delete calls must forward `rcjav_path`, or the host may read the wrong `config.json` and derive the wrong allowlist.
+
+### Toolbar popup setting gates auto-check (2026-05-20)
+
+**Decision:** `triggers.toolbarClick` does not remove the MV3 popup, but it does gate whether the popup auto-runs `checkTab` on open. If disabled, popup stays idle until user clicks Re-Scan.
+
+### Quick search and ID padding (2026-05-20)
+
+**Decision:** rc-jav canonical JAV IDs use at least 3 digits (`ABC-027`) and preserve 4+ digit IDs (`ABCD-1294`). Quick search emits canonical uppercase globs only.
+
+**Reasoning:** user clarified real JAV filenames are never `ABC-27` or `ABC-0027`; they are `ABC-027`. User also never uses lowercase filenames, so quick search should not use rclone `--ignore-case` because it added noticeable delay.
+
+**Operational note:** this changes cache keys. Run `python rc-jav.py --scan` in `D:\DEV\Project\rclone-jav` after this change.
+
+### No-match overlay metadata (2026-05-20)
+
+**Decision:** host search response includes `cache_meta` and `scanned_remotes` from rc-jav JSON so no-match overlays can show what was scanned instead of falling back to "library".
+
+### IBW-902z trailing letter (2026-05-20)
+
+**Decision:** minimal regex fix in extension only. NOT a full variant-suffix rewrite of the index.
+
+**Reasoning:** User's library uses one ID per number (either `IBW-902` OR `IBW-902z`, not both). Page titles failing on `IBW-902z` is the real bug. Extension regex now matches optional trailing letter and discards it. rc-jav's index continues to strip trailing letters at extract_id time. Effective: extension queries `IBW-902` for any title `IBW-902` or `IBW-902z`, finds the file regardless of how it's named on rclone.
+
+**Revisit if:** both `IBW-902.mp4` and `IBW-902z.mp4` ever coexist in library — they'd collide on the same ID. Then implement variant suffix (#var_Z) end-to-end.
+
+### Native messaging host name stayed `com.rcjav.host`
+
+When extension was renamed `rclonex` → `rclone-jav`, the NM host name was NOT renamed. Reason: zero user impact (it's an internal identifier in registry/manifest), but every rename costs registry rewrites + script churn. Not worth it.
+
+### WinCatalog backslash normalization
+
+Deferred. See `D:\DEV\Project\rclone-jav\TODO.md`. Catalog CSV paths use Windows `\` which leaks through to popup display, breaking filename split. Fix is 2 lines in rc-jav.py `load_catalog_csv` / `load_catalog_xml` — apply when catalog feature is used heavily.
+
+## When making changes
+
+- Extension settings schema change → update `DEFAULT_SETTINGS` in background.js AND defaults in options.html + options.js load()
+- New native messaging action → handler in rcjav-host.py + DISPATCH map + extension code that sends it
+- New options pane → sidebar item in options.html + new `.pane` div + load/save bindings in options.js
+- Any rc-jav.py CLI change → host invocation in rcjav-host.py handle_search must keep pace
diff --git a/background.js b/background.js
new file mode 100644
index 0000000..d086f83
--- /dev/null
+++ b/background.js
@@ -0,0 +1,1077 @@
+// rclonex background service worker.
+// Owns the native-messaging port, dispatches lookups, draws badge/notifications.
+
+const HOST_NAME = "com.rcjav.host";
+
+const DEFAULT_SETTINGS = {
+  triggers: {
+    autoEveryPage: false,
+    autoKnownSites: false,
+    autoPageLoad: true,
+    autoSpaNavigation: true,
+    toolbarClick: true,   // popup
+    contextMenu: true,
+    keyboardShortcut: true,
+  },
+  knownSitePatterns: [],
+  quickMode: true,
+  cacheStaleHours: 24,
+  scanPaused: false,
+  rcjavPath: "",  // empty = use host's built-in default
+  showOverlay: true,
+  overlayPosition: "top-right",  // top-left, top-right, bottom-left, bottom-right
+  overlayDuration: 5,             // seconds
+  overlayGlow: false,             // subtle outer glow
+  overlayGlowColor: "#6ec1ff",    // glow hue when enabled
+  overlayGlowBlur: 10,            // softness in px
+  overlayGlowSpread: 0,           // expansion in px
+  overlayGlowOpacity: 0.35,       // 0.05–1.0
+  // No-match overlay (opt-in, separate from match overlay)
+  noMatchOverlay: false,
+  noMatchPosition: "top-right",
+  noMatchDuration: 5,
+  noMatchGlow: false,
+  noMatchGlowColor: "#ff6666",
+  noMatchGlowBlur: 10,
+  noMatchGlowSpread: 0,
+  noMatchGlowOpacity: 0.35,
+  // Deletion (opt-in, off by default).
+  enableDelete: false,
+  deleteMode: "trash",  // "trash" or "permanent"
+  trashDir: "cq:personal-files/.rclone-jav-trash",
+  partPatterns: [],
+  // Multi-library profiles. Each profile overrides source/target for searches.
+  // Empty array = no profiles defined (use rc-jav config.json defaults).
+  profiles: [],       // [{name: string, source: string[], target: string[]}]
+  activeProfile: "", // name of active profile; "" = use config.json defaults
+};
+
+// ----- settings helpers -----
+
+// Deep-merge stored settings on top of defaults so a partial save (older version,
+// imported file missing keys) doesn't blank out nested objects like `triggers`.
+// One level deep is enough — that's the only nesting we ship.
+function mergeSettings(defaults, stored) {
+  const out = Object.assign({}, defaults);
+  if (!stored || typeof stored !== "object") return out;
+  for (const k of Object.keys(stored)) {
+    const dv = defaults[k];
+    const sv = stored[k];
+    if (dv && typeof dv === "object" && !Array.isArray(dv)
+        && sv && typeof sv === "object" && !Array.isArray(sv)) {
+      out[k] = Object.assign({}, dv, sv);
+    } else {
+      out[k] = sv;
+    }
+  }
+  return out;
+}
+
+async function getSettings() {
+  const got = await chrome.storage.sync.get("settings");
+  return mergeSettings(DEFAULT_SETTINGS, got.settings);
+}
+
+async function setSettings(s) {
+  await chrome.storage.sync.set({ settings: s });
+}
+
+// ----- native messaging -----
+
+let nativePort = null;
+const pending = new Map(); // requestId -> {resolve, reject}
+let nextReqId = 1;
+let pendingPicker = null;
+const badgeSpinners = new Map(); // tabId -> interval handle
+
+// MV3 evicts the service worker after ~30s of inactivity. A long-running native
+// call (--quick on a slow remote, --scan-backed search of a large library) can
+// outlive that window and the reply would arrive to a fresh SW with an empty
+// `pending` Map. Keep the SW alive by pulsing a Chrome API call while we have
+// outstanding native requests.
+let keepaliveTimer = null;
+function pulseKeepalive() {
+  // Any extension API call resets the idle timer. getPlatformInfo is cheap.
+  chrome.runtime.getPlatformInfo(() => { /* noop */ });
+  if (pending.size > 0) {
+    keepaliveTimer = setTimeout(pulseKeepalive, 20_000);
+  } else {
+    keepaliveTimer = null;
+  }
+}
+function ensureKeepalive() {
+  if (keepaliveTimer == null && pending.size > 0) {
+    keepaliveTimer = setTimeout(pulseKeepalive, 20_000);
+  }
+}
+
+function ensurePort() {
+  if (nativePort) return nativePort;
+  try {
+    nativePort = chrome.runtime.connectNative(HOST_NAME);
+  } catch (e) {
+    console.error("rclonex: connectNative failed", e);
+    throw e;
+  }
+  nativePort.onMessage.addListener((msg) => {
+    const p = pending.get(msg.req_id);
+    if (p) {
+      pending.delete(msg.req_id);
+      p.resolve(msg);
+    }
+  });
+  nativePort.onDisconnect.addListener(() => {
+    const err = chrome.runtime.lastError;
+    console.warn("rclonex: native host disconnected", err);
+    nativePort = null;
+    for (const [, p] of pending) p.reject(new Error(err?.message || "host disconnected"));
+    pending.clear();
+  });
+  return nativePort;
+}
+
+// Hard cap so a hung host (rclone deadlock, host crash mid-reply, Chrome silently
+// disconnecting the port over the 1 MiB cap) doesn't leave UI spinners forever.
+const NATIVE_CALL_TIMEOUT_MS = 90_000;
+
+function nativeCall(payload, timeoutMs = NATIVE_CALL_TIMEOUT_MS) {
+  const port = ensurePort();
+  const reqId = nextReqId++;
+  const msg = Object.assign({ req_id: reqId }, payload);
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      if (pending.has(reqId)) {
+        pending.delete(reqId);
+        reject(new Error(`native host timeout after ${timeoutMs}ms (action=${payload.action || "?"})`));
+      }
+    }, timeoutMs);
+    pending.set(reqId, {
+      resolve: (v) => { clearTimeout(timer); resolve(v); },
+      reject: (e) => { clearTimeout(timer); reject(e); },
+    });
+    ensureKeepalive();
+    try { port.postMessage(msg); }
+    catch (e) {
+      clearTimeout(timer);
+      pending.delete(reqId);
+      // The port is in a broken state — null it so the next call reconnects
+      // instead of reusing the dead handle and failing the same way.
+      if (nativePort === port) nativePort = null;
+      reject(e);
+    }
+  });
+}
+
+function classifyNativeError(err) {
+  const msg = String(err && err.message ? err.message : err || "");
+  if (/forbidden/i.test(msg)) return "forbidden";
+  if (/not found|specified native messaging host/i.test(msg)) return "not_found";
+  if (/disconnected/i.test(msg)) return "disconnected";
+  if (/timeout/i.test(msg)) return "timeout";
+  return "unknown";
+}
+
+// ----- ID extraction -----
+// Ask the content script (which has DOM + adapters). Fall back to tab.title if injection
+// hasn't run (e.g. chrome:// pages).
+
+const BUILTIN_ID_NORMALIZERS = [
+  { re: /\bFC2-?PPV-?(\d{4,})\b/i, fmt: "FC2-PPV-$1" },
+  { re: /\bFC2-(\d{4,})\b/i, fmt: "FC2-PPV-$1" },
+];
+
+function applyNormalizers(text, userList) {
+  const all = [...(userList || []), ...BUILTIN_ID_NORMALIZERS];
+  for (const n of all) {
+    let re;
+    try { re = n.re instanceof RegExp ? n.re : new RegExp(n.re, "i"); } catch { continue; }
+    const m = text.match(re);
+    if (m) return n.fmt.replace(/\$(\d)/g, (_, i) => m[+i] || "");
+  }
+  return null;
+}
+
+function traceTextExtraction(text, userList) {
+  const raw = String(text || "");
+  if (!raw) return { id: null, source: "none", raw: "" };
+  const all = [...(userList || []), ...BUILTIN_ID_NORMALIZERS];
+  for (let index = 0; index < all.length; index++) {
+    const n = all[index];
+    let re;
+    try { re = n.re instanceof RegExp ? n.re : new RegExp(n.re, "i"); } catch { continue; }
+    const m = raw.match(re);
+    if (!m) continue;
+    const id = n.fmt.replace(/\$(\d)/g, (_, i) => m[+i] || "").toUpperCase();
+    return {
+      id,
+      source: index < (userList || []).length ? "custom normalizer" : "built-in normalizer",
+      raw: raw.slice(0, 300),
+      pattern: String(n.re),
+      replacement: n.fmt,
+    };
+  }
+  let m = raw.match(/\b([A-Za-z][A-Za-z0-9]{1,})-(\d{2,7})[a-zA-Z]?\b/);
+  if (!m) m = raw.match(/\b([A-Za-z][A-Za-z0-9]{1,})(\d{3,5})[a-zA-Z]?\b/);
+  return m ? {
+    id: `${m[1].toUpperCase()}-${m[2]}`,
+    source: "generic ID regex",
+    raw: raw.slice(0, 300),
+  } : { id: null, source: "none", raw: raw.slice(0, 300) };
+}
+
+async function extractIdFromTitle(title) {
+  if (!title) return null;
+  const { settings = {} } = await chrome.storage.sync.get("settings");
+  const fromNormalizer = applyNormalizers(title, settings.idNormalizers || []);
+  if (fromNormalizer) return fromNormalizer.toUpperCase();
+  // Optional trailing letter (e.g. IBW-902z) absorbed but not part of the ID.
+  let m = title.match(/\b([A-Za-z][A-Za-z0-9]{1,})-(\d{2,7})[a-zA-Z]?\b/);
+  if (!m) m = title.match(/\b([A-Za-z][A-Za-z0-9]{1,})(\d{3,5})[a-zA-Z]?\b/);
+  if (!m) return null;
+  return `${m[1].toUpperCase()}-${m[2]}`;
+}
+
+async function extractIdFromTab(tab) {
+  if (!tab || tab.id == null) return null;
+  try {
+    const r = await chrome.tabs.sendMessage(tab.id, { type: "extract-id" });
+    if (r && r.id) return r;
+  } catch (e) {
+    // Content script not present (e.g. brave://, chrome://, file://). Use title fallback.
+  }
+  const id = await extractIdFromTitle(tab.title);
+  return id ? { id, source: "title" } : null;
+}
+
+// ----- core: check a tab -----
+
+function tabCacheKey(tabId) { return `tabResult:${tabId}`; }
+const ACTIVITY_KEY = "recentActivity";
+const ACTIVITY_MAX = 60;
+
+function summarizeActivity(tab, result, trigger = "page") {
+  const timings = result && result.timings ? result.timings : {};
+  const url = tab && tab.url ? tab.url : "";
+  const title = tab && tab.title ? tab.title : "";
+  const id = result && result.id ? result.id : "";
+  const ok = !!(result && result.ok);
+  const hits = Number(result && result.hits) || 0;
+  const noId = result?.reason === "no JAV ID found";
+  return {
+    ts: Date.now(),
+    trigger,
+    id,
+    ok,
+    hits,
+    outcome: ok ? (hits > 0 ? "hit" : "miss") : (noId ? "no_id" : result?.paused ? "paused" : "error"),
+    reason: result?.reason || result?.error || "",
+    mode: result?.cached ? "session" : result?.search_mode || "",
+    url: url.slice(0, 700),
+    title: title.slice(0, 300),
+    total_ms: Number.isFinite(timings.total_ms) ? timings.total_ms : null,
+    native_ms: Number.isFinite(timings.native_ms) ? timings.native_ms : null,
+    extract_ms: Number.isFinite(timings.extract_ms) ? timings.extract_ms : null,
+  };
+}
+
+async function recordActivity(tab, result, trigger = "page") {
+  try {
+    const row = summarizeActivity(tab, result, trigger);
+    const got = await chrome.storage.local.get(ACTIVITY_KEY);
+    const old = Array.isArray(got[ACTIVITY_KEY]) ? got[ACTIVITY_KEY] : [];
+    await chrome.storage.local.set({ [ACTIVITY_KEY]: [row, ...old].slice(0, ACTIVITY_MAX) });
+  } catch {}
+}
+
+async function persistTabResult(tab, result) {
+  if (!tab || tab.id == null) return;
+  try {
+    await chrome.storage.session.set({
+      [tabCacheKey(tab.id)]: { url: tab.url || "", result, ts: Date.now() },
+    });
+  } catch {}
+}
+
+async function getTabResult(tab) {
+  if (!tab || tab.id == null) return null;
+  try {
+    const got = await chrome.storage.session.get(tabCacheKey(tab.id));
+    const entry = got[tabCacheKey(tab.id)];
+    if (!entry) return null;
+    if (entry.url !== (tab.url || "")) return null;
+    return entry;
+  } catch { return null; }
+}
+
+chrome.tabs.onUpdated.addListener((tabId, changeInfo) => {
+  if (changeInfo.url) chrome.storage.session.remove(tabCacheKey(tabId));
+});
+chrome.tabs.onRemoved.addListener((tabId) => {
+  stopBadgeSpinner(tabId);
+  chrome.storage.session.remove(tabCacheKey(tabId));
+  lastAutoCheck.delete(tabId);
+  const t = pendingSpaTimer.get(tabId);
+  if (t) { clearTimeout(t); pendingSpaTimer.delete(tabId); }
+});
+
+async function checkTab(tab) {
+  if (!tab) return { ok: false, reason: "no tab" };
+  const settings = await getSettings();
+  if (settings.scanPaused) {
+    if (tab.id != null) setBadge(tab.id, "Ⅱ", "#66551f");
+    const r = { ok: false, paused: true, reason: "scanning paused" };
+    await recordActivity(tab, r, "page");
+    return r;
+  }
+  const t0 = performance.now();
+  startBadgeSpinner(tab.id);
+  const extractStart = performance.now();
+  const ext = await extractIdFromTab(tab);
+  const extractMs = Math.round(performance.now() - extractStart);
+  const id = ext && ext.id;
+  if (!id) {
+    stopBadgeSpinner(tab.id);
+    setBadge(tab.id, "?", "#888");
+    const r = {
+      ok: false,
+      reason: "no JAV ID found",
+      no_match_kind: "no_id",
+      no_match_title: "No JAV ID extracted",
+      no_match_detail: "The page title, URL, and matching site adapters did not yield an ID.",
+      title: tab.title,
+    };
+    await persistTabResult(tab, r);
+    await recordActivity(tab, r, "page");
+    return r;
+  }
+  let result;
+  try {
+    const nativeStart = performance.now();
+    const prof = (settings.profiles || []).find((p) => p.name === settings.activeProfile);
+    result = await nativeCall({
+      action: "search",
+      id,
+      quick: !!settings.quickMode,
+      stale_hours: settings.cacheStaleHours || 24,
+      rcjav_path: settings.rcjavPath || "",
+      part_patterns: settings.partPatterns || [],
+      source_override: prof ? (prof.source || []) : [],
+      target_override: prof ? (prof.target || []) : [],
+    });
+    result.timings = Object.assign({}, result.timings || {}, {
+      extract_ms: extractMs,
+      native_ms: Math.round(performance.now() - nativeStart),
+      total_ms: Math.round(performance.now() - t0),
+    });
+  } catch (e) {
+    stopBadgeSpinner(tab.id);
+    setBadge(tab.id, "!", "#c33");
+    const r = {
+      ok: false,
+      reason: "host error: " + e.message,
+      error: e.message,
+      error_kind: classifyNativeError(e),
+      extension_id: chrome.runtime.id,
+      id,
+    };
+    await persistTabResult(tab, r);
+    await recordActivity(tab, r, "page");
+    return r;
+  }
+  const hits = result.hits || 0;
+  stopBadgeSpinner(tab.id);
+  if (result.ok) {
+    setBadge(tab.id, hits > 0 ? String(hits) : "✗", hits > 0 ? "#3a7" : "#a33");
+  } else {
+    setBadge(tab.id, "!", "#c33");
+  }
+  const r = Object.assign({ id, cached: false, ts: Date.now() }, result);
+  await persistTabResult(tab, r);
+  await recordActivity(tab, r, "page");
+  return r;
+}
+
+function startBadgeSpinner(tabId) {
+  if (typeof tabId !== "number") return;
+  stopBadgeSpinner(tabId);
+  const frames = ["-", "\\", "|", "/"];
+  let i = 0;
+  chrome.action.setBadgeBackgroundColor({ tabId, color: "#446" });
+  chrome.action.setBadgeText({ tabId, text: frames[i] });
+  const handle = setInterval(() => {
+    i = (i + 1) % frames.length;
+    chrome.action.setBadgeText({ tabId, text: frames[i] });
+  }, 180);
+  badgeSpinners.set(tabId, handle);
+}
+
+function stopBadgeSpinner(tabId) {
+  if (typeof tabId !== "number") return;
+  const handle = badgeSpinners.get(tabId);
+  if (!handle) return;
+  clearInterval(handle);
+  badgeSpinners.delete(tabId);
+}
+
+function setBadge(tabId, text, color) {
+  if (typeof tabId !== "number") return;
+  chrome.action.setBadgeText({ tabId, text });
+  chrome.action.setBadgeBackgroundColor({ tabId, color });
+}
+
+function notify(title, message) {
+  chrome.notifications.create({
+    type: "basic",
+    iconUrl: chrome.runtime.getURL("icons/icon-128.png"),
+    title,
+    message,
+  }, () => {
+    // Some platforms reject notifications silently or report icon failures via
+    // runtime.lastError. Touch it here so Brave does not leave an uncaught
+    // extension error on the management page.
+    void chrome.runtime.lastError;
+  });
+}
+
+// ----- triggers -----
+
+// Context menu
+async function ensureContextMenu() {
+  const s = await getSettings();
+  chrome.contextMenus.removeAll(() => {
+    if (s.triggers.contextMenu) {
+      chrome.contextMenus.create({
+        id: "rclonex-check-page",
+        title: "rclone-jav: Scan",
+        contexts: ["page", "link", "selection"],
+      });
+    }
+  });
+}
+
+async function stashAndShow(r) {
+  // Stash latest result so popup shows it instead of re-running.
+  await chrome.storage.session.set({ lastResult: { ...r, ts: Date.now() } });
+  // Try notification (may be silently blocked).
+  if (r.id) notify(r.id, r.message || (r.hits > 0 ? `${r.hits} hit(s)` : "NOT FOUND"));
+  else notify("rclonex", r.reason || "no result");
+  // Open the popup so the table is visible. openPopup is MV3, gated to user gestures
+  // — keyboard shortcut qualifies.
+  try { await chrome.action.openPopup(); } catch (e) { /* not all platforms support */ }
+}
+
+// Send the match/no-match overlay to a tab, using the user's overlay settings.
+// Mirrors the same logic in the auto-detection path.
+async function sendOverlay(tab, r, s) {
+  if (!tab || !r || !r.ok || !r.id) return;
+  // Always stash so popup shows latest if user opens it.
+  await chrome.storage.session.set({ lastResult: { ...r, ts: Date.now() } });
+  try {
+    if (r.hits > 0 && s.showOverlay !== false) {
+      await chrome.tabs.sendMessage(tab.id, {
+        type: "show-overlay",
+        kind: "match",
+        result: r,
+        position: s.overlayPosition || "top-right",
+        duration: Number(s.overlayDuration) || 5,
+        glow: !!s.overlayGlow,
+        glowColor: s.overlayGlowColor || "#6ec1ff",
+        glowBlur: Number(s.overlayGlowBlur ?? 10),
+        glowSpread: Number(s.overlayGlowSpread ?? 0),
+        glowOpacity: Number(s.overlayGlowOpacity ?? 0.35),
+      });
+    } else if (r.hits === 0 && s.noMatchOverlay === true) {
+      await chrome.tabs.sendMessage(tab.id, {
+        type: "show-overlay",
+        kind: "no-match",
+        result: r,
+        position: s.noMatchPosition || "top-right",
+        duration: Number(s.noMatchDuration) || 5,
+        glow: !!s.noMatchGlow,
+        glowColor: s.noMatchGlowColor || "#ff6666",
+        glowBlur: Number(s.noMatchGlowBlur ?? 10),
+        glowSpread: Number(s.noMatchGlowSpread ?? 0),
+        glowOpacity: Number(s.noMatchGlowOpacity ?? 0.35),
+      });
+    }
+  } catch (e) { /* content script may not be present on chrome:// pages */ }
+}
+
+chrome.contextMenus.onClicked.addListener(async (info, tab) => {
+  if (info.menuItemId !== "rclonex-check-page" || !tab) return;
+  const s = await getSettings();
+  const r = await checkTab(tab);
+  await sendOverlay(tab, r, s);
+});
+
+// Keyboard
+chrome.commands.onCommand.addListener(async (cmd) => {
+  if (cmd !== "check-current-page") return;
+  const s = await getSettings();
+  if (!s.triggers.keyboardShortcut) return;
+  const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!tab) return;
+  const r = await checkTab(tab);
+  await stashAndShow(r);
+});
+
+// Auto-trigger via tab update event (handles both "auto every page" and "auto known sites").
+// Normal page loads fire on `status: "complete"`. SPA in-page navigations only emit a
+// `changeInfo.url` (no following `complete`), so we arm a deferred timer on url-change
+// and let `complete` cancel it if it arrives — that way regular loads don't double-fire
+// or fire before the DOM/title are ready.
+const lastAutoCheck = new Map(); // tabId -> ts of last fired check
+const pendingSpaTimer = new Map(); // tabId -> setTimeout handle awaiting SPA settle
+const AUTO_DEBOUNCE_MS = 800;
+const SPA_SETTLE_MS = 800;
+
+async function maybeAutoCheck(tabId, tab, reason) {
+  const s = await getSettings();
+  if (reason === "complete" && s.triggers.autoPageLoad === false) return;
+  if (reason === "spa-url" && s.triggers.autoSpaNavigation === false) return;
+  let shouldRun = false;
+  if (s.triggers.autoEveryPage) shouldRun = true;
+  else if (s.triggers.autoKnownSites && matchesKnownSite(tab.url, s.knownSitePatterns)) shouldRun = true;
+  if (!shouldRun) return;
+  const now = Date.now();
+  const prev = lastAutoCheck.get(tabId) || 0;
+  if (now - prev < AUTO_DEBOUNCE_MS) return;
+  lastAutoCheck.set(tabId, now);
+  const r = await checkTab(tab);
+  if (!r || !r.ok || !r.id) return;
+  await sendOverlay(tab, r, s);
+}
+
+chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
+  if (!tab || !tab.url) return;
+  // Status reached "complete": DOM and title are settled. Cancel any pending
+  // SPA timer for this tab and fire immediately.
+  if (changeInfo.status === "complete") {
+    const t = pendingSpaTimer.get(tabId);
+    if (t) { clearTimeout(t); pendingSpaTimer.delete(tabId); }
+    maybeAutoCheck(tabId, tab, "complete");
+    return;
+  }
+  // SPA in-page navigation: only url changes, never status. Defer the check so
+  // the page has a chance to update its title/DOM, and so a real reload (which
+  // also emits a url change before complete) doesn't double-fire.
+  if (typeof changeInfo.url === "string") {
+    const prev = pendingSpaTimer.get(tabId);
+    if (prev) clearTimeout(prev);
+    const handle = setTimeout(() => {
+      pendingSpaTimer.delete(tabId);
+      // Refetch the tab so we see the latest title; the one in this closure
+      // may be stale by now.
+      chrome.tabs.get(tabId, (fresh) => {
+        if (chrome.runtime.lastError || !fresh) return;
+        maybeAutoCheck(tabId, fresh, "spa-url");
+      });
+    }, SPA_SETTLE_MS);
+    pendingSpaTimer.set(tabId, handle);
+  }
+});
+
+function matchesKnownSite(url, patterns) {
+  if (!patterns || patterns.length === 0) return false;
+  let host;
+  try { host = new URL(url).hostname; } catch { return false; }
+  for (const p of patterns) {
+    // Bare domain matches the apex AND any subdomain. Wildcard form does the same.
+    const variants = [p];
+    if (p.startsWith("*.")) variants.push(p.slice(2));
+    else if (!p.includes("*")) variants.push("*." + p);
+    for (const v of variants) {
+      const re = new RegExp("^" + v.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$", "i");
+      if (re.test(host)) return true;
+    }
+  }
+  return false;
+}
+
+// ----- popup / options bridge -----
+
+chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
+  if (msg.type === "check-tab") {
+    (async () => {
+      let tab;
+      if (msg.tabId) tab = await chrome.tabs.get(msg.tabId);
+      else [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
+      // Honor cache unless caller forces a refresh.
+      if (!msg.force) {
+        const cached = await getTabResult(tab);
+        if (cached) {
+          sendResponse(Object.assign({ tab }, cached.result, { cached: true, ts: cached.ts }));
+          return;
+        }
+      }
+      const r = await checkTab(tab);
+      sendResponse(Object.assign({ tab, cached: false }, r));
+    })();
+    return true; // async response
+  }
+  if (msg.type === "settings-changed") {
+    ensureContextMenu();
+    sendResponse({ ok: true });
+    return false;
+  }
+  if (msg.type === "recent-activity") {
+    (async () => {
+      try {
+        const got = await chrome.storage.local.get(ACTIVITY_KEY);
+        sendResponse({ ok: true, entries: Array.isArray(got[ACTIVITY_KEY]) ? got[ACTIVITY_KEY] : [] });
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "clear-recent-activity") {
+    (async () => {
+      try {
+        await chrome.storage.local.set({ [ACTIVITY_KEY]: [] });
+        sendResponse({ ok: true });
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "manual-query") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        if (settings.scanPaused) {
+          await recordActivity(null, { ok: false, paused: true, id: msg.id || "", reason: "scanning paused" }, "manual");
+          sendResponse({ ok: false, paused: true, error: "scanning paused" });
+          return;
+        }
+        const prof = (settings.profiles || []).find((p) => p.name === settings.activeProfile);
+        const nativeStart = performance.now();
+        const r = await nativeCall({
+          action: msg.action || "search",
+          id: msg.id,
+          name: msg.name,
+          quick: msg.quick,
+          stale_hours: settings.cacheStaleHours || 24,
+          rcjav_path: settings.rcjavPath || "",
+          part_patterns: settings.partPatterns || [],
+          source_override: prof ? (prof.source || []) : [],
+          target_override: prof ? (prof.target || []) : [],
+        });
+        r.timings = Object.assign({}, r.timings || {}, {
+          native_ms: Math.round(performance.now() - nativeStart),
+          total_ms: Math.round(performance.now() - nativeStart),
+        });
+        const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
+        await recordActivity(activeTab, Object.assign({ id: msg.id || "", cached: false }, r), "manual");
+        sendResponse(r);
+      } catch (e) {
+        await recordActivity(null, { ok: false, id: msg.id || "", reason: e.message }, "manual");
+        sendResponse({ ok: false, error: e.message, error_kind: classifyNativeError(e), extension_id: chrome.runtime.id });
+      }
+    })();
+    return true;
+  }
+  if (msg.type === "bulk-query") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        if (settings.scanPaused) {
+          sendResponse({ ok: false, paused: true, error: "scanning paused" });
+          return;
+        }
+        const prof = (settings.profiles || []).find((p) => p.name === settings.activeProfile);
+        const r = await nativeCall({
+          action: "bulk_search",
+          queries: msg.queries || [],
+          quick: !!msg.quick,
+          stale_hours: settings.cacheStaleHours || 24,
+          rcjav_path: settings.rcjavPath || "",
+          part_patterns: settings.partPatterns || [],
+          source_override: prof ? (prof.source || []) : [],
+          target_override: prof ? (prof.target || []) : [],
+        }, 600_000);
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message, error_kind: classifyNativeError(e), extension_id: chrome.runtime.id }); }
+    })();
+    return true;
+  }
+  if (msg.type === "dupe-review") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        const prof = (settings.profiles || []).find((p) => p.name === settings.activeProfile);
+        const r = await nativeCall({
+          action: "dupe_review",
+          rcjav_path: settings.rcjavPath || "",
+          part_patterns: settings.partPatterns || [],
+          source_override: prof ? (prof.source || []) : [],
+          target_override: prof ? (prof.target || []) : [],
+        }, 600_000);
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "delete_batch") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        if (!settings.enableDelete) {
+          sendResponse({ ok: false, error: "deletion is disabled in options" });
+          return;
+        }
+        const r = await nativeCall({
+          action: "delete_batch",
+          paths: msg.paths,
+          mode: settings.deleteMode || "trash",
+          trash_dir: settings.trashDir || "",
+          rcjav_path: settings.rcjavPath || "",
+        }, 600_000);
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "delete-skipped") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        if (!settings.enableDelete) {
+          sendResponse({ ok: false, error: "deletion is disabled in options" });
+          return;
+        }
+        const r = await nativeCall({
+          action: "delete_skipped",
+          paths: msg.paths,
+          mode: settings.deleteMode || "trash",
+          trash_dir: settings.trashDir || "",
+          rcjav_path: settings.rcjavPath || "",
+        }, 120_000);
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "get-keep-ranking") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        const r = await nativeCall({ action: "get_keep_ranking", rcjav_path: settings.rcjavPath || "" }, 10_000);
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "save-keep-ranking") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        const r = await nativeCall({
+          action: "save_keep_ranking",
+          rcjav_path: settings.rcjavPath || "",
+          keep_ranking: msg.keep_ranking,
+        }, 10_000);
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "library_issues") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        const r = await nativeCall({
+          action: "library_issues",
+          rcjav_path: settings.rcjavPath || "",
+        }, 60_000);
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "rename_file") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        const r = await nativeCall({
+          action: "rename_file",
+          rcjav_path: settings.rcjavPath || "",
+          remote: msg.remote,
+          old_path: msg.old_path,
+          new_path: msg.new_path,
+        }, 60_000);
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "rename_files_batch") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        const r = await nativeCall({
+          action: "rename_files_batch",
+          rcjav_path: settings.rcjavPath || "",
+          renames: msg.renames,
+        }, 300_000);
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "start-picker") {
+    (async () => {
+      // Find most-recently-active normal web tab (not the options page itself).
+      const all = await chrome.tabs.query({});
+      const web = all.filter((t) => t.url && /^https?:/.test(t.url));
+      web.sort((a, b) => (b.lastAccessed || 0) - (a.lastAccessed || 0));
+      const tab = web[0];
+      if (!tab) {
+        sendResponse({ ok: false, error: "no http/https tab open — switch to the target site first" });
+        return;
+      }
+      try {
+        // Bring the target tab to the front so user can click on it.
+        await chrome.tabs.update(tab.id, { active: true });
+        if (tab.windowId != null) await chrome.windows.update(tab.windowId, { focused: true });
+        // Force-inject content.js — handles tabs that were opened before the extension
+        // (or before its most recent reload).
+        try {
+          await chrome.scripting.executeScript({ target: { tabId: tab.id }, files: ["content.js"] });
+        } catch (e) { /* may fail on chrome:// pages, fine */ }
+        await chrome.tabs.sendMessage(tab.id, { type: "start-picker" });
+        pendingPicker = { tabId: tab.id, sender: msg.from || "options" };
+        sendResponse({ ok: true, tabId: tab.id, url: tab.url });
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "test-active-page") {
+    (async () => {
+      const all = await chrome.tabs.query({});
+      const web = all.filter((t) => t.url && /^https?:/.test(t.url));
+      web.sort((a, b) => (b.lastAccessed || 0) - (a.lastAccessed || 0));
+      const tab = web[0];
+      if (!tab) {
+        sendResponse({ ok: false, error: "no http/https tab open" });
+        return;
+      }
+      try {
+        try {
+          await chrome.scripting.executeScript({ target: { tabId: tab.id }, files: ["content.js"] });
+        } catch (e) { /* content script may already be present */ }
+        const extracted = await chrome.tabs.sendMessage(tab.id, {
+          type: "trace-extract-id",
+          adapters: Array.isArray(msg.adapters) ? msg.adapters : undefined,
+          normalizers: Array.isArray(msg.normalizers) ? msg.normalizers : undefined,
+        });
+        sendResponse({ ok: true, tab: { id: tab.id, url: tab.url, title: tab.title }, extracted });
+      } catch (e) {
+        sendResponse({ ok: false, error: e.message, tab: { id: tab.id, url: tab.url, title: tab.title } });
+      }
+    })();
+    return true;
+  }
+  if (msg.type === "test-id-text") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        const normalizers = Array.isArray(msg.normalizers) ? msg.normalizers : (settings.idNormalizers || []);
+        sendResponse({ ok: true, extracted: traceTextExtraction(msg.text || "", normalizers) });
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "picker-result" || msg.type === "picker-cancelled") {
+    // Forward to options page via storage.session — easiest cross-page bus
+    chrome.storage.session.set({ lastPickerResult: { ...msg, ts: Date.now() } });
+    sendResponse({ ok: true });
+    return false;
+  }
+  if (msg.type === "delete-file") {
+    (async () => {
+      const settings = await getSettings();
+      if (!settings.enableDelete) {
+        sendResponse({ ok: false, error: "deletion is disabled in options" });
+        return;
+      }
+      try {
+        const r = await nativeCall({
+          action: "delete",
+          path: msg.path,
+          mode: settings.deleteMode || "trash",
+          trash_dir: settings.trashDir || "",
+          rcjav_path: settings.rcjavPath || "",
+        });
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "get-settings") {
+    (async () => sendResponse(await getSettings()))();
+    return true;
+  }
+  if (msg.type === "diagnostics") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        const r = await nativeCall({
+          action: "diagnostics",
+          rcjav_path: settings.rcjavPath || "",
+          extension_settings: {
+            quick_mode: settings.quickMode !== false,
+            active_profile: settings.activeProfile || "",
+            profile_count: (settings.profiles || []).length,
+            auto_every_page: !!settings.triggers?.autoEveryPage,
+            auto_known_sites: !!settings.triggers?.autoKnownSites,
+          },
+        });
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message, error_kind: classifyNativeError(e), extension_id: chrome.runtime.id }); }
+    })();
+    return true;
+  }
+  if (msg.type === "cache-status") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        const r = await nativeCall({
+          action: "cache_status",
+          rcjav_path: settings.rcjavPath || "",
+          stale_hours: settings.cacheStaleHours || 24,
+        });
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message, error_kind: classifyNativeError(e), extension_id: chrome.runtime.id }); }
+    })();
+    return true;
+  }
+  if (msg.type === "host-status") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        const r = await nativeCall({
+          action: "host_status",
+          rcjav_path: settings.rcjavPath || "",
+          extension_id: chrome.runtime.id,
+        }, 20_000);
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message, error_kind: classifyNativeError(e), extension_id: chrome.runtime.id }); }
+    })();
+    return true;
+  }
+  if (msg.type === "repair-host") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        const r = await nativeCall({
+          action: "host_repair",
+          rcjav_path: settings.rcjavPath || "",
+          extension_id: chrome.runtime.id,
+        }, 20_000);
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message, error_kind: classifyNativeError(e), extension_id: chrome.runtime.id }); }
+    })();
+    return true;
+  }
+  if (msg.type === "ping-host") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        const r = await nativeCall({ action: "ping", rcjav_path: msg.rcjavPath ?? settings.rcjavPath ?? "" });
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "run-scan") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        if (settings.scanPaused) {
+          sendResponse({ ok: false, paused: true, error: "scanning paused" });
+          return;
+        }
+        // Scans can take minutes — use a longer timeout (10 min cap).
+        const r = await nativeCall(
+          {
+            action: "scan",
+            scan_since: msg.scanSince || "",
+            scan_roots: Array.isArray(msg.scanRoots) ? msg.scanRoots : [],
+            rcjav_path: settings.rcjavPath || "",
+            part_patterns: settings.partPatterns || [],
+            timeout: 600,
+          },
+          600_000,
+        );
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "scan-cancel") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        const r = await nativeCall({ action: "scan_cancel", rcjav_path: settings.rcjavPath || "" }, 5_000);
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "scan-progress") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        const r = await nativeCall({ action: "scan_progress", rcjav_path: settings.rcjavPath || "" }, 5_000);
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "scan-clear") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        const r = await nativeCall({ action: "scan_clear", rcjav_path: settings.rcjavPath || "" }, 5_000);
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "list-remotes") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        const r = await nativeCall({ action: "list_remotes", rcjav_path: settings.rcjavPath || "" }, 20_000);
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "recent-deletes") {
+    (async () => {
+      try {
+        const settings = await getSettings();
+        const r = await nativeCall({ action: "recent_deletes", limit: msg.limit || 20, rcjav_path: settings.rcjavPath || "" });
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+  if (msg.type === "undo-delete") {
+    (async () => {
+      const settings = await getSettings();
+      if (!settings.enableDelete) {
+        sendResponse({ ok: false, error: "deletion is disabled in options" });
+        return;
+      }
+      try {
+        const r = await nativeCall({ action: "undo_delete", dst: msg.dst, path: msg.path, rcjav_path: settings.rcjavPath || "" });
+        sendResponse(r);
+      } catch (e) { sendResponse({ ok: false, error: e.message }); }
+    })();
+    return true;
+  }
+});
+
+// On install / startup, build context menu
+chrome.runtime.onInstalled.addListener(() => ensureContextMenu());
+chrome.runtime.onStartup.addListener(() => ensureContextMenu());
diff --git a/content.js b/content.js
new file mode 100644
index 0000000..87f22e7
--- /dev/null
+++ b/content.js
@@ -0,0 +1,542 @@
+// rclonex content script.
+// Responsibilities:
+//   1. On request, extract a JAV ID from the page via site adapters → URL → title.
+//   2. Implement an interactive element picker so the user can fill in a selector
+//      by clicking on the page from the options UI.
+//
+// Wrapped in an IIFE + global flag so re-injection (e.g. via chrome.scripting.executeScript
+// when manifest content_scripts already loaded it) is a no-op instead of a SyntaxError.
+
+if (!window.__rclonex_loaded__) {
+window.__rclonex_loaded__ = true;
+(() => {
+
+// Optional single trailing letter (e.g. IBW-902z) is matched but discarded —
+// rc-jav's index already drops trailing letters too, so query "IBW-902" finds the file.
+const ID_RE_DASHED = /\b([A-Za-z][A-Za-z0-9]{1,})-(\d{2,7})[a-zA-Z]?\b/;
+const ID_RE_UNDASHED = /\b([A-Za-z][A-Za-z0-9]{1,})(\d{3,5})[a-zA-Z]?\b/;
+
+// Built-in studio normalizers — applied BEFORE generic ID regex.
+// Each entry: { re: RegExp, fmt: string ($1, $2 = capture groups) }.
+// User-added normalizers from settings are tried before these.
+const BUILTIN_ID_NORMALIZERS = [
+  // FC2-PPV in any dash configuration: FC2PPV12345, FC2-PPV12345, FC2-PPV-12345
+  { re: /\bFC2-?PPV-?(\d{4,})\b/i, fmt: "FC2-PPV-$1" },
+  // Some sites display FC2 IDs without the PPV segment: FC2-1841460.
+  { re: /\bFC2-(\d{4,})\b/i, fmt: "FC2-PPV-$1" },
+];
+
+const BUILTIN_SITE_ADAPTERS = [
+  { host: "clearjav.com", selector: "div.meta-chip > h3.meta-chip__value" },
+];
+
+function applyNormalizers(text, userList) {
+  const all = [...(userList || []), ...BUILTIN_ID_NORMALIZERS];
+  for (const n of all) {
+    let re;
+    try { re = n.re instanceof RegExp ? n.re : new RegExp(n.re, "i"); } catch { continue; }
+    const m = text.match(re);
+    if (m) {
+      // Apply fmt with $1..$9 substitution
+      return n.fmt.replace(/\$(\d)/g, (_, i) => m[+i] || "");
+    }
+  }
+  return null;
+}
+
+let _userNormalizers = [];
+async function loadUserNormalizers() {
+  try {
+    const { settings = {} } = await chrome.storage.sync.get("settings");
+    _userNormalizers = Array.isArray(settings.idNormalizers) ? settings.idNormalizers : [];
+  } catch { _userNormalizers = []; }
+}
+chrome.storage.onChanged?.addListener?.((changes, area) => {
+  if (area === "sync" && changes.settings) {
+    _userNormalizers = Array.isArray(changes.settings.newValue?.idNormalizers)
+      ? changes.settings.newValue.idNormalizers : [];
+  }
+});
+loadUserNormalizers();
+
+function normalizeId(text, userNormalizers = _userNormalizers) {
+  if (!text) return null;
+  // Try user-defined + built-in normalizers first (FC2-PPV-style oddballs).
+  const fromNormalizer = applyNormalizers(text, userNormalizers);
+  if (fromNormalizer) return fromNormalizer.toUpperCase();
+  let m = text.match(ID_RE_DASHED);
+  if (!m) m = text.match(ID_RE_UNDASHED);
+  if (!m) return null;
+  // Preserve the digits exactly as they appear (incl. leading zeros) — rc-jav --quick
+  // hands the glob "<ID>*" to rclone --include, which is literal, not numeric.
+  return `${m[1].toUpperCase()}-${m[2]}`;
+}
+
+function hostMatches(pattern, host) {
+  // Glob: '*' = any chars. Case-insensitive.
+  // Convenience: a bare domain (no '*.') ALSO matches any subdomain — and vice versa.
+  //   "clearjav.com" matches both "clearjav.com" and "www.clearjav.com"
+  //   "*.clearjav.com" matches both "www.clearjav.com" and bare "clearjav.com"
+  const patterns = [pattern];
+  if (pattern.startsWith("*.")) patterns.push(pattern.slice(2));
+  else if (!pattern.includes("*")) patterns.push("*." + pattern);
+  for (const p of patterns) {
+    const re = new RegExp("^" + p.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$", "i");
+    if (re.test(host)) return true;
+  }
+  return false;
+}
+
+function tryAdapters(adapters, userNormalizers = _userNormalizers) {
+  const host = location.hostname;
+  for (const a of adapters) {
+    if (!a.host || !a.selector) continue;
+    if (!hostMatches(a.host, host)) continue;
+    const selectors = a.selector.split(",").map((s) => s.trim()).filter(Boolean);
+    for (const sel of selectors) {
+      let el;
+      try { el = document.querySelector(sel); } catch { continue; }
+      if (!el) continue;
+      const text = (el.textContent || el.innerText || "").trim();
+      const id = normalizeId(text, userNormalizers);
+      if (id) return { id, source: "adapter", adapter: a.host, selector: sel, raw: text.slice(0, 200) };
+    }
+  }
+  return null;
+}
+
+function tryUrl(userNormalizers = _userNormalizers) {
+  const raw = decodeURIComponent(location.pathname + " " + location.search);
+  const id = normalizeId(raw, userNormalizers);
+  return id ? { id, source: "url", raw: raw.slice(0, 200) } : null;
+}
+
+function tryTitle(userNormalizers = _userNormalizers) {
+  const id = normalizeId(document.title, userNormalizers);
+  return id ? { id, source: "title", raw: document.title.slice(0, 200) } : null;
+}
+
+async function getAdapters() {
+  const { settings = {} } = await chrome.storage.sync.get("settings");
+  const user = Array.isArray(settings.siteAdapters) ? settings.siteAdapters : [];
+  const builtin = [...BUILTIN_SITE_ADAPTERS, ...(window.__RCLONEX_BUILTIN_ADAPTERS__ || [])];
+  // User entries override built-ins for the same host (user list iterated first).
+  return [...user, ...builtin];
+}
+
+async function tracePageExtraction(overrides = {}) {
+  const savedAdapters = await getAdapters();
+  const adapters = Array.isArray(overrides.adapters)
+    ? [...overrides.adapters, ...BUILTIN_SITE_ADAPTERS, ...(window.__RCLONEX_BUILTIN_ADAPTERS__ || [])]
+    : savedAdapters;
+  const normalizers = Array.isArray(overrides.normalizers) ? overrides.normalizers : _userNormalizers;
+  const adapter = tryAdapters(adapters, normalizers);
+  const title = tryTitle(normalizers);
+  const url = tryUrl(normalizers);
+  return {
+    id: (adapter || title || url || {}).id || null,
+    source: (adapter || title || url || {}).source || "none",
+    selected: adapter || title || url || null,
+    stages: { adapter, title, url },
+  };
+}
+
+// ---------- picker ----------
+
+let pickerActive = false;
+let pickerOverlay = null;
+let pickerHighlight = null;
+
+function buildSelector(el) {
+  if (!el || el.nodeType !== 1) return null;
+
+  // Helper: does selector hit an element with the same JAV-ID-bearing text?
+  // We don't require strict uniqueness — adapter uses first match anyway, so as long
+  // as the FIRST match has the right textContent (or contains the same ID), we win.
+  const wantedText = (el.textContent || "").trim();
+  const wantedId = normalizeId(wantedText);
+  const matchesTarget = (sel) => {
+    let first;
+    try { first = document.querySelector(sel); } catch { return false; }
+    if (!first) return false;
+    if (first === el) return true;
+    const t = (first.textContent || "").trim();
+    if (wantedId && normalizeId(t) === wantedId) return true;
+    return t === wantedText;
+  };
+
+  const tag = el.tagName.toLowerCase();
+  const candidates = [];
+
+  // 1. #id if any
+  if (el.id) candidates.push("#" + CSS.escape(el.id));
+
+  // 2. tag + single class (each class on its own — pick shortest that works)
+  if (el.classList.length) {
+    for (const cls of el.classList) candidates.push(`${tag}.${CSS.escape(cls)}`);
+    // 3. tag + all classes combined
+    candidates.push(tag + Array.from(el.classList).map((c) => "." + CSS.escape(c)).join(""));
+    // 4. just .class (no tag) for each class
+    for (const cls of el.classList) candidates.push("." + CSS.escape(cls));
+  }
+
+  // 5. just tag (rarely unique but cheap)
+  candidates.push(tag);
+
+  // Try simplest first.
+  candidates.sort((a, b) => a.length - b.length);
+  for (const sel of candidates) {
+    if (matchesTarget(sel)) return sel;
+  }
+
+  // Fall back: build qualified ancestor path.
+  const parts = [];
+  let cur = el;
+  while (cur && cur.nodeType === 1 && cur.tagName.toLowerCase() !== "html") {
+    let part = cur.tagName.toLowerCase();
+    if (cur.id) { part += "#" + CSS.escape(cur.id); parts.unshift(part); break; }
+    if (cur.classList.length) {
+      part += Array.from(cur.classList).slice(0, 3).map((c) => "." + CSS.escape(c)).join("");
+    }
+    const siblings = cur.parentNode ? Array.from(cur.parentNode.children).filter((s) => s.tagName === cur.tagName) : [];
+    if (siblings.length > 1) {
+      part += `:nth-of-type(${siblings.indexOf(cur) + 1})`;
+    }
+    parts.unshift(part);
+    const candidate = parts.join(" > ");
+    if (matchesTarget(candidate)) return candidate;
+    cur = cur.parentElement;
+  }
+  return parts.join(" > ");
+}
+
+function startPicker() {
+  if (pickerActive) return;
+  pickerActive = true;
+  pickerOverlay = document.createElement("div");
+  pickerOverlay.style.cssText = "position:fixed;top:12px;left:50%;transform:translateX(-50%);z-index:2147483647;background:#ff8800;color:#000;padding:10px 16px;font:bold 14px/1.3 -apple-system,Segoe UI,sans-serif;border-radius:4px;box-shadow:0 4px 16px rgba(0,0,0,.5);pointer-events:none;max-width:90vw;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;";
+  pickerOverlay.textContent = "rclonex picker: hover an element, click to pick — Esc to cancel";
+  document.body.appendChild(pickerOverlay);
+  pickerHighlight = document.createElement("div");
+  pickerHighlight.style.cssText = "position:fixed;pointer-events:none;z-index:2147483646;border:3px dashed #ff8800;background:rgba(255,136,0,.25);box-shadow:0 0 0 9999px rgba(0,0,0,.35);box-sizing:border-box;transition:all 0.05s;";
+  document.body.appendChild(pickerHighlight);
+  document.addEventListener("mousemove", onPickerMove, true);
+  document.addEventListener("click", onPickerClick, true);
+  document.addEventListener("keydown", onPickerKey, true);
+}
+
+function stopPicker() {
+  if (!pickerActive) return;
+  pickerActive = false;
+  document.removeEventListener("mousemove", onPickerMove, true);
+  document.removeEventListener("click", onPickerClick, true);
+  document.removeEventListener("keydown", onPickerKey, true);
+  if (pickerOverlay) pickerOverlay.remove();
+  if (pickerHighlight) pickerHighlight.remove();
+  pickerOverlay = null;
+  pickerHighlight = null;
+}
+
+function onPickerMove(e) {
+  const el = document.elementFromPoint(e.clientX, e.clientY);
+  if (!el || el === pickerHighlight || el === pickerOverlay) return;
+  const r = el.getBoundingClientRect();
+  pickerHighlight.style.top = r.top + "px";
+  pickerHighlight.style.left = r.left + "px";
+  pickerHighlight.style.width = r.width + "px";
+  pickerHighlight.style.height = r.height + "px";
+  pickerOverlay.textContent = `rclonex: ${el.tagName.toLowerCase()}${el.id ? "#" + el.id : ""}${el.className && typeof el.className === "string" ? "." + el.className.trim().split(/\s+/).slice(0, 2).join(".") : ""} — click to pick, Esc to cancel`;
+}
+
+function onPickerClick(e) {
+  e.preventDefault();
+  e.stopPropagation();
+  const el = document.elementFromPoint(e.clientX, e.clientY);
+  if (!el || el === pickerHighlight || el === pickerOverlay) { stopPicker(); return; }
+  const selector = buildSelector(el);
+  const text = (el.textContent || "").trim().slice(0, 200);
+  const id = normalizeId(text);
+  chrome.runtime.sendMessage({
+    type: "picker-result",
+    host: location.hostname,
+    selector,
+    sample: text,
+    detectedId: id,
+  });
+  stopPicker();
+}
+
+function onPickerKey(e) {
+  if (e.key === "Escape") { stopPicker(); chrome.runtime.sendMessage({ type: "picker-cancelled" }); }
+}
+
+// ---------- message dispatch ----------
+
+// ---------- overlay (auto-trigger hit toast) ----------
+
+const OVERLAY_ID = "rclonex-overlay";
+
+function showOverlay(result, opts = {}) {
+  if (!result) return;
+  const kind = opts.kind || "match";
+  if (kind === "match" && (!result.structured || result.structured.length === 0)) return;
+  document.getElementById(OVERLAY_ID)?.remove();
+  document.getElementById("rclonex-overlay-style")?.remove();
+
+  const position = opts.position || "top-right";
+  const durationMs = Math.max(500, Math.round((opts.duration || 5) * 1000));
+  const glow = !!opts.glow;
+  const glowColor = opts.glowColor || "#6ec1ff";
+  const glowBlur = Number.isFinite(opts.glowBlur) ? opts.glowBlur : 10;
+  const glowSpread = Number.isFinite(opts.glowSpread) ? opts.glowSpread : 0;
+  const glowOpacity = Number.isFinite(opts.glowOpacity) ? opts.glowOpacity : 0.35;
+
+  const hexToRgba = (hex, a) => {
+    const m = String(hex).match(/^#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
+    if (!m) return `rgba(110,193,255,${a})`;
+    return `rgba(${parseInt(m[1], 16)},${parseInt(m[2], 16)},${parseInt(m[3], 16)},${a})`;
+  };
+
+  const positions = {
+    "top-right":    { top: "16px", right: "16px", bottom: "auto", left: "auto", enter: "translateY(-10px)" },
+    "top-left":     { top: "16px", left: "16px",  bottom: "auto", right: "auto", enter: "translateY(-10px)" },
+    "bottom-right": { bottom: "16px", right: "16px", top: "auto", left: "auto", enter: "translateY(10px)" },
+    "bottom-left":  { bottom: "16px", left: "16px",  top: "auto", right: "auto", enter: "translateY(10px)" },
+  };
+  const p = positions[position] || positions["top-right"];
+
+  const glowCss = glow
+    ? `box-shadow: 0 6px 20px rgba(0,0,0,0.55), 0 0 ${glowBlur}px ${glowSpread}px ${hexToRgba(glowColor, glowOpacity)};`
+    : "box-shadow: 0 8px 30px rgba(0,0,0,0.6);";
+
+  const css = `
+    #${OVERLAY_ID} {
+      position: fixed;
+      top: ${p.top}; right: ${p.right}; bottom: ${p.bottom}; left: ${p.left};
+      width: 380px;
+      z-index: 2147483647; background: #1a1a1a; color: #ddd;
+      border: 1px solid #2a2a2a; border-radius: 6px;
+      font-family: -apple-system, Segoe UI, sans-serif; font-size: 13px;
+      ${glowCss}
+      overflow: hidden;
+      opacity: 0; transform: ${p.enter};
+      transition: opacity 0.25s, transform 0.25s;
+    }
+    #${OVERLAY_ID}.show { opacity: 1; transform: translateY(0); }
+    #${OVERLAY_ID} .rx-header {
+      padding: 8px 12px; background: #1e3a1e; color: #afa;
+      font-size: 13px; font-weight: 600;
+      display: flex; align-items: center; gap: 8px;
+    }
+    #${OVERLAY_ID} .rx-title {
+      min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+    }
+    #${OVERLAY_ID} .rx-mode {
+      margin-left: auto;
+      background: rgba(0,0,0,0.28);
+      border: 1px solid rgba(255,255,255,0.18);
+      color: currentColor;
+      padding: 1px 6px;
+      border-radius: 10px;
+      font-size: 10px;
+      font-weight: 700;
+      letter-spacing: 0.4px;
+      flex-shrink: 0;
+    }
+    #${OVERLAY_ID} .rx-header.rx-no-match { background: #3a1e1e; color: #faa; }
+    #${OVERLAY_ID} .rx-subline {
+      padding: 8px 12px; background: #0d0d0d; color: #aaa;
+      font-size: 12px; font-family: Consolas, monospace;
+      word-break: break-all;
+    }
+    #${OVERLAY_ID} .rx-miss-detail {
+      padding: 8px 12px; background: #15110d; color: #ccb98f;
+      font-size: 11px; line-height: 1.45;
+      border-top: 1px solid #30251a;
+    }
+    #${OVERLAY_ID} .rx-close {
+      cursor: pointer; color: #8a8a8a; font-size: 16px;
+      width: 18px; height: 18px; line-height: 16px; text-align: center;
+      border-radius: 3px;
+      flex-shrink: 0;
+    }
+    #${OVERLAY_ID} .rx-close:hover { background: rgba(255,255,255,0.1); color: #fff; }
+    #${OVERLAY_ID} .rx-body { padding: 6px; background: #0d0d0d; max-height: 360px; overflow-y: auto; }
+    #${OVERLAY_ID} .rx-hit {
+      background: #161616; border: 1px solid #2a2a2a; border-radius: 4px;
+      padding: 10px; margin-bottom: 6px;
+    }
+    #${OVERLAY_ID} .rx-hit:last-child { margin-bottom: 0; }
+    #${OVERLAY_ID} .rx-file { color: #fff; font-weight: 600; font-size: 13px; word-break: break-all; margin: 0 0 4px; }
+    #${OVERLAY_ID} .rx-path { color: #aaa; font-size: 12px; font-family: Consolas, monospace; word-break: break-all; margin: 0 0 6px; line-height: 1.45; }
+    #${OVERLAY_ID} .rx-plabel { color: #555; font-weight: 600; }
+    #${OVERLAY_ID} .rx-meta { display: flex; align-items: center; gap: 8px; font-size: 11px; line-height: 1; }
+    #${OVERLAY_ID} .rx-size { color: #6ec1ff; font-weight: 600; }
+    #${OVERLAY_ID} .rx-src { background: #2a2a1a; color: #ffcc44; padding: 1px 6px; border-radius: 10px; font-size: 10px; font-weight: 600; letter-spacing: 0.3px; }
+    #${OVERLAY_ID} .rx-src.source { background: #1a3a1a; color: #66dd66; }
+    #${OVERLAY_ID} .rx-src.catalog { background: #1a2a3a; color: #66bbff; }
+    #${OVERLAY_ID} .rx-reason { background: #202a32; border: 1px solid #314453; color: #9dccff; padding: 1px 6px; border-radius: 10px; font-size: 10px; font-weight: 600; }
+    #${OVERLAY_ID} .rx-bar-wrap { height: 3px; background: #222; }
+    #${OVERLAY_ID} .rx-bar {
+      height: 100%; background: linear-gradient(90deg, #6ec1ff, #66dd66);
+      transform-origin: left; transform: scaleX(1);
+      animation: rxshrink ${durationMs}ms linear forwards;
+    }
+    @keyframes rxshrink { from { transform: scaleX(1); } to { transform: scaleX(0); } }
+  `;
+  let styleEl = document.getElementById("rclonex-overlay-style");
+  if (!styleEl) {
+    styleEl = document.createElement("style");
+    styleEl.id = "rclonex-overlay-style";
+    styleEl.textContent = css;
+    document.head.appendChild(styleEl);
+  }
+
+  const root = document.createElement("div");
+  root.id = OVERLAY_ID;
+
+  const idLabel = result.id || result.structured?.[0]?.jav_id || "?";
+  const cacheTag = result.cached && result.ts ? ` [session ${fmtOverlayAge(result.ts)}]` : "";
+  const modeLabel = result.cached ? "SESSION" : result.search_mode === "quick" ? "LIVE" : result.search_mode === "cached" ? "CACHE" : "";
+  const header = document.createElement("div");
+  header.className = "rx-header" + (kind === "no-match" ? " rx-no-match" : "");
+  const titleText = kind === "match"
+    ? `✓ ${idLabel} — ${result.hits} hit(s)${cacheTag}`
+    : `✗ ${idLabel} — NOT IN LIBRARY${cacheTag}`;
+  if (kind === "match") {
+    header.innerHTML = `<span class="rx-title">${escapeOverlay(titleText)}</span>${modeLabel ? `<span class="rx-mode">${escapeOverlay(modeLabel)}</span>` : ""}<span class="rx-close" title="dismiss">×</span>`;
+  } else {
+    header.innerHTML = `<span class="rx-title">${escapeOverlay(titleText)}</span>${modeLabel ? `<span class="rx-mode">${escapeOverlay(modeLabel)}</span>` : ""}<span class="rx-close" title="dismiss">×</span>`;
+  }
+  root.appendChild(header);
+
+  if (kind === "match") {
+    const body = document.createElement("div");
+    body.className = "rx-body";
+    for (const h of result.structured) {
+      const filename = h.path.split("/").pop();
+      const idx = h.full_path.lastIndexOf("/");
+      const dir = idx >= 0 ? h.full_path.slice(0, idx) : h.full_path;
+      const srcCls = h.source === "Source" ? "rx-src source"
+                   : h.source === "Catalog" ? "rx-src catalog" : "rx-src";
+      const confidence = h.match_confidence ? ` · ${h.match_confidence}` : "";
+      const reason = h.match_reason
+        ? `<span class="rx-reason" title="Matched ${escapeOverlay(h.matched_query || h.jav_id || "")}${escapeOverlay(confidence)}">${escapeOverlay(h.match_reason)}</span>`
+        : "";
+      const card = document.createElement("div");
+      card.className = "rx-hit";
+      card.innerHTML = `
+        <div class="rx-file">${escapeOverlay(filename)}</div>
+        <div class="rx-path"><span class="rx-plabel">Path:</span> ${escapeOverlay(dir)}</div>
+        <div class="rx-meta">
+          <span class="${srcCls}">${escapeOverlay(h.source.toUpperCase())}</span>
+          <span class="rx-size">${escapeOverlay(h.size_human)}</span>
+          ${reason}
+        </div>
+      `;
+      body.appendChild(card);
+    }
+    root.appendChild(body);
+  } else {
+    // No-match: a single sub-line saying what was scanned.
+    const sub = document.createElement("div");
+    sub.className = "rx-subline";
+    const remotes = (result.scanned_remotes && result.scanned_remotes.length)
+      ? result.scanned_remotes.join(", ")
+      : (Object.keys(result.cache_meta || {})[0] || "library");
+    sub.innerHTML = `<span class="rx-plabel">Scanned:</span> ${escapeOverlay(remotes)}`;
+    root.appendChild(sub);
+    if (result.no_match_title || result.no_match_detail) {
+      const detail = document.createElement("div");
+      detail.className = "rx-miss-detail";
+      detail.innerHTML = `<strong>${escapeOverlay(result.no_match_title || "No match")}</strong>${result.no_match_detail ? `<div>${escapeOverlay(result.no_match_detail)}</div>` : ""}`;
+      root.appendChild(detail);
+    }
+  }
+
+  const barWrap = document.createElement("div");
+  barWrap.className = "rx-bar-wrap";
+  const bar = document.createElement("div");
+  bar.className = "rx-bar";
+  barWrap.appendChild(bar);
+  root.appendChild(barWrap);
+
+  document.body.appendChild(root);
+  requestAnimationFrame(() => root.classList.add("show"));
+
+  // Hover pauses the countdown
+  root.addEventListener("mouseenter", () => { bar.style.animationPlayState = "paused"; });
+  root.addEventListener("mouseleave", () => { bar.style.animationPlayState = "running"; });
+  // Close button
+  header.querySelector(".rx-close").addEventListener("click", (e) => {
+    e.stopPropagation();
+    dismissOverlay(root);
+  });
+  // Animation end → fade out
+  bar.addEventListener("animationend", () => dismissOverlay(root));
+}
+
+function dismissOverlay(root) {
+  root.classList.remove("show");
+  setTimeout(() => root.remove(), 300);
+}
+
+function escapeOverlay(s) {
+  return String(s).replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
+}
+
+function fmtOverlayAge(ts) {
+  if (!ts) return "";
+  const s = Math.round((Date.now() - ts) / 1000);
+  if (s < 60) return `${s}s ago`;
+  if (s < 3600) return `${Math.round(s / 60)}m ago`;
+  return `${Math.round(s / 3600)}h ago`;
+}
+
+// ---------- message dispatch ----------
+
+chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
+  if (msg.type === "show-overlay") {
+    showOverlay(msg.result, {
+      kind: msg.kind || "match",
+      position: msg.position,
+      duration: msg.duration,
+      glow: msg.glow,
+      glowColor: msg.glowColor,
+      glowBlur: msg.glowBlur,
+      glowSpread: msg.glowSpread,
+      glowOpacity: msg.glowOpacity,
+    });
+    sendResponse({ ok: true });
+    return false;
+  }
+  if (msg.type === "extract-id") {
+    (async () => {
+      const trace = await tracePageExtraction();
+      sendResponse(trace.selected || { id: null, source: "none" });
+    })();
+    return true;
+  }
+  if (msg.type === "trace-extract-id") {
+    (async () => {
+      sendResponse(await tracePageExtraction({
+        adapters: msg.adapters,
+        normalizers: msg.normalizers,
+      }));
+    })();
+    return true;
+  }
+  if (msg.type === "start-picker") {
+    startPicker();
+    sendResponse({ ok: true });
+    return false;
+  }
+  if (msg.type === "stop-picker") {
+    stopPicker();
+    sendResponse({ ok: true });
+    return false;
+  }
+});
+
+})();
+} // end if !__rclonex_loaded__
diff --git a/docs/EXTENSION_ID.md b/docs/EXTENSION_ID.md
new file mode 100644
index 0000000..ca47e64
--- /dev/null
+++ b/docs/EXTENSION_ID.md
@@ -0,0 +1,37 @@
+# Stable Extension ID
+
+Chrome and Brave derive an extension ID from the extension public key. If the
+key changes, the extension ID changes too.
+
+Why this matters for rclone-jav:
+
+- `chrome.storage.sync` settings are scoped to the extension ID.
+- The native messaging host manifest authorizes specific extension IDs in
+  `allowed_origins`.
+- Moving or reloading an unpacked extension without a fixed key can make settings
+  appear to vanish and can break native messaging.
+
+## Recommended workflow
+
+1. Export settings from Options -> Backup before changing install paths.
+2. Keep Production loaded from a stable folder path.
+3. For a permanently stable unpacked ID, add a fixed Chrome extension public key
+   to `manifest.json` under the `key` field.
+4. After the ID changes intentionally, update the native host manifest
+   `allowed_origins` and re-register the host.
+5. Import the settings backup.
+
+## Packed extension workflow
+
+If you pack the extension as a `.crx`, save the generated `.pem` private key.
+Packing future versions with the same `.pem` produces the same extension ID.
+
+Do not lose or share the `.pem`; it controls the extension identity.
+
+## Unpacked extension workflow
+
+For unpacked installs, use the public key derived from the `.pem` as
+`manifest.json`'s `key` value. The value must be the Chrome extension public key
+format, not an arbitrary string.
+
+Same manifest key = same extension ID.
diff --git a/docs/INSTALL.md b/docs/INSTALL.md
new file mode 100644
index 0000000..e289462
--- /dev/null
+++ b/docs/INSTALL.md
@@ -0,0 +1,227 @@
+# rclone-jav — Install Guide
+
+End-to-end setup for a fresh PC. Tested on Windows 11 + Brave Stable. Should also work for Chrome with minor path tweaks.
+
+> **PC2 / Staging note:** Paths below use `D:\DEV\Extensions\Production\rclone-jav\`. On the Staging PC, substitute `Production` → `Staging` throughout.
+
+---
+
+## Prerequisites
+
+1. **Python 3.9+** on PATH. Verify:
+   ```
+   python --version
+   ```
+   Note the install location (e.g. `C:\Python314\python.exe`). Needed in step 6.
+
+2. **rclone** on PATH with your remotes configured (`rclone config`). Verify:
+   ```
+   rclone version
+   rclone lsf <your-remote>: -R --include "*IPZZ*"   # sanity check
+   ```
+
+   **If "rclone not found" in a fresh PowerShell** despite being installed: Windows Terminal sometimes caches the old PATH across new pwsh sessions. Quick fix for the current session:
+   ```powershell
+   $env:Path += ';C:\Programs\rclone'    # or wherever rclone.exe lives
+   rclone version
+   ```
+   Permanent fix: close Windows Terminal completely (all windows, not just tabs) and reopen — fresh pwsh will inherit the registered user PATH. If still missing, sign out/in once.
+
+3. **Brave** (Stable, Beta, Dev, or Nightly — install registers all four channels).
+
+4. **rich** (Python package, used by `rc-jav.py`):
+   ```
+   pip install rich
+   ```
+
+---
+
+## Step 1 — Place the files
+
+Copy both project folders:
+
+```
+D:\DEV\Project\rclone-jav\     ← rc-jav.py + cache.json + config.json + wincatalog\
+D:\DEV\Extensions\Production\rclone-jav\     ← manifest + host\
+```
+
+`rcjav-host.bat` is now portable — it uses Windows' `py` launcher or falls back to `python` on PATH. **No per-machine Python path edits needed** as long as Python is on PATH.
+
+If you put the project folder elsewhere than `D:\DEV\Project\rclone-jav`, you'll either:
+- Edit the `RC_JAV` constant at the top of `D:\DEV\Extensions\Production\rclone-jav\host\rcjav-host.py`, OR
+- Set it via the extension's Options → **Setup & Transfer → rc-jav script path** (works without editing files).
+
+---
+
+## Step 2 — Configure rc-jav defaults
+
+Edit `D:\DEV\Project\rclone-jav\config.json` (create if missing):
+
+```json
+{
+  "default_target": ["cq:personal-files/JAV"],
+  "default_source": [],
+  "default_catalog": []
+}
+```
+
+Or set interactively:
+
+```
+cd D:\DEV\Project\rclone-jav
+python rc-jav.py --target cq:personal-files/JAV --save
+```
+
+Verify:
+
+```
+python rc-jav.py --search IPZZ-860 -q --basic
+```
+
+Should return a hit in ~1–2 seconds.
+
+---
+
+## Step 3 — Load the Brave extension
+
+1. Open `brave://extensions`.
+2. Toggle **Developer mode** ON (top-right).
+3. Click **Load unpacked**.
+4. Pick `D:\DEV\Extensions\Production\rclone-jav` (the folder containing `manifest.json`).
+5. **Copy the Extension ID** shown on the card. Example: `gnimjpgbgehbefdkdjodcimefdedgeho`.
+
+---
+
+## Step 4 — Register the native messaging host
+
+Easiest: double-click `D:\DEV\Extensions\Production\rclone-jav\host\register-host.bat`. It prompts for the ID and runs the installer.
+
+Or manually in PowerShell (any window — script self-elevates):
+
+```powershell
+cd D:\DEV\Extensions\Production\rclone-jav\host
+.\install-host.ps1 -ExtensionId <paste-the-extension-id>
+```
+
+UAC will prompt — click **Yes**. The script writes:
+
+- **Manifest:** `D:\DEV\Extensions\Production\rclone-jav\host\com.rcjav.host.json` (UTF-8 no BOM)
+- **Registry (HKLM + HKCU):**
+  - `\Software\BraveSoftware\Brave-Browser\NativeMessagingHosts\com.rcjav.host`
+  - `\Software\Google\Chrome\NativeMessagingHosts\com.rcjav.host`
+  - `\Software\WOW6432Node\Google\Chrome\NativeMessagingHosts\com.rcjav.host`
+  - `\Software\Chromium\NativeMessagingHosts\com.rcjav.host`
+
+HKLM is **required** — Brave on Windows often ignores HKCU. The script writes both as belt-and-suspenders.
+
+Verify registry:
+
+```powershell
+reg query "HKLM\Software\BraveSoftware\Brave-Browser\NativeMessagingHosts\com.rcjav.host"
+```
+
+Should print `(Default)  REG_SZ  D:\DEV\Extensions\Production\rclone-jav\host\com.rcjav.host.json`.
+
+---
+
+## Step 5 — Fully restart Brave
+
+Closing windows is not enough. Brave caches NM host registrations at process startup.
+
+```powershell
+Get-Process brave | Stop-Process -Force
+```
+
+Or Task Manager → kill every `brave.exe`. Then reopen Brave.
+
+---
+
+## Step 6 — Verify
+
+1. Click the rclone-jav toolbar icon.
+2. Popup opens, auto-runs a check on the current tab.
+3. Click **Ping host**. Expect green banner: `host ok: 0.1.0`.
+
+If green, you're done.
+
+---
+
+## Step 7 — Choose triggers (optional)
+
+Click the gear icon in the popup (or right-click extension → Options) to enable:
+
+- Auto-check every page load
+- Auto-check on listed JAV sites (configurable host patterns)
+- Toolbar icon popup auto-check
+- Right-click context menu
+- Keyboard shortcut (default `Alt+J`, rebind at `brave://extensions/shortcuts`)
+
+Enable any combination.
+
+---
+
+## Troubleshooting
+
+**Popup shows "host unreachable" / "Specified native messaging host not found":**
+- Did UAC prompt complete? Re-run `install-host.ps1`.
+- `reg query "HKLM\Software\BraveSoftware\Brave-Browser\NativeMessagingHosts\com.rcjav.host"` must return the manifest path. If empty: install script failed silently.
+- Manifest file must exist at the registered path AND be valid JSON AND have **no BOM**. Check: `python -c "import json; json.load(open(r'D:\DEV\Extensions\Production\rclone-jav\host\com.rcjav.host.json'))"` — no error = valid.
+- Fully kill all `brave.exe`, then reopen.
+- `allowed_origins` in the manifest must match the current extension ID. If you reloaded the extension and the ID changed, re-run `install-host.ps1`.
+
+**Popup shows "host error: ...":**
+- Host launched but Python died. Read `D:\DEV\Extensions\Production\rclone-jav\host\logs\rcjav-host-stderr.log`.
+- Common cause: wrong `python.exe` path in `rcjav-host.bat`, or wrong `RC_JAV` path in `rcjav-host.py`.
+
+**Badge stays `?`:**
+- Page title has no JAV ID. Extension regex: `[A-Z]{2,}-?[0-9]{2,5}`.
+
+**Badge stays `!`:**
+- Host returned non-zero exit code. Check `host\logs\rcjav-host-stderr.log` and `host\logs\rcjav-host.log`.
+
+**Search returns no hits but the file exists:**
+- Cache may be stale. Run `python rc-jav.py --scan` to refresh, or pass `--quick` (extension does this by default).
+
+**Brave verbose logging for deep debug:**
+```powershell
+& "C:\Program Files\BraveSoftware\Brave-Browser\Application\brave.exe" --enable-logging=stderr --vmodule="*native_messaging*=2" 2>&1 | Tee-Object D:\brave-nm.log
+# Click ping in extension, then:
+Select-String -Path D:\brave-nm.log -Pattern "native|rcjav|com\.rc" -Context 0,2
+```
+
+`Can't find manifest for native messaging host com.rcjav.host` = registry not seen → re-run installer + restart Brave.
+
+---
+
+## Uninstall
+
+```powershell
+# Remove registry entries (admin)
+$keys = @(
+  'HKLM:\Software\BraveSoftware\Brave-Browser\NativeMessagingHosts\com.rcjav.host',
+  'HKLM:\Software\Google\Chrome\NativeMessagingHosts\com.rcjav.host',
+  'HKLM:\Software\WOW6432Node\Google\Chrome\NativeMessagingHosts\com.rcjav.host',
+  'HKLM:\Software\Chromium\NativeMessagingHosts\com.rcjav.host',
+  'HKCU:\Software\BraveSoftware\Brave-Browser\NativeMessagingHosts\com.rcjav.host',
+  'HKCU:\Software\Google\Chrome\NativeMessagingHosts\com.rcjav.host',
+  'HKCU:\Software\Chromium\NativeMessagingHosts\com.rcjav.host'
+)
+foreach ($k in $keys) { Remove-Item -Path $k -Force -ErrorAction SilentlyContinue }
+```
+
+Then remove the extension at `brave://extensions`, and delete `D:\DEV\Extensions\Production\rclone-jav\`.
+
+---
+
+## Key gotchas learned the hard way
+
+| Gotcha | Symptom | Fix |
+|---|---|---|
+| UTF-8 BOM in manifest | "Specified native messaging host not found." | Write file with `[System.Text.UTF8Encoding]::new($false)` |
+| HKCU-only registration | Same error, even with valid manifest | Register HKLM (admin) |
+| Buffered Python stdio | Host launches but Brave times out | `python -u` in .bat |
+| Text-mode stdio on Windows | First message corrupts immediately | `msvcrt.setmode(..., os.O_BINARY)` in host script |
+| stderr on stdout | Garbage bytes break length prefix | Redirect stderr to file in .bat |
+| Extension reload != Brave restart | Stale NM cache | Kill all `brave.exe` then reopen |
+| Extension ID changes on reload | allowed_origins mismatch | Re-run `install-host.ps1` (or `register-host.bat`) with new ID |
+| em-dashes (—) in .ps1 file + Windows PS 5.1 + no BOM | `Missing closing '}'` parse errors at random lines | Strip em-dashes (replace with `-`), or save .ps1 with UTF-8 BOM, or invoke via `pwsh` instead of `powershell.exe` |
diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 0000000..abe8d81
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,79 @@
+# rclone-jav
+
+Brave extension that extracts JAV IDs from the active page and checks them against your local rc-jav library via a native-messaging Python host.
+
+> **Setup:** see [`INSTALL.md`](./INSTALL.md). This file documents how it works once installed.
+
+## Architecture
+
+```
+Brave tab title (e.g. "MILK-257")
+  ─► content/background script extracts ID
+  ─► chrome.runtime.connectNative("com.rcjav.host")
+  ─► rcjav-host.bat  →  rcjav-host.py
+  ─► python rc-jav.py --search MILK-257 --basic --no-color
+  ─► result back through the port
+  ─► popup / notification / badge
+```
+
+Long-lived port: Brave keeps the host process alive while the connection is open, so subsequent lookups don't pay Python startup cost.
+
+## Triggers (all available, enable any combination in Options)
+
+| Trigger | Behavior |
+|---|---|
+| **Auto-check every page load** | Fires `chrome.tabs.onUpdated`. Badge shows hit count or `?` when no JAV ID detected. Noisy. |
+| **Auto-check on known JAV sites** | Same as above but gated by host patterns (e.g. `*.javdb.com`). |
+| **Toolbar icon popup** | Click the icon → popup can run a check on the active tab. The Scan Behavior toggle gates popup auto-check. |
+| **Right-click context menu** | "rclone-jav: check this page". Shows a desktop notification. |
+| **Keyboard shortcut (Alt+J)** | Rebind at `brave://extensions/shortcuts`. |
+
+Enable them all to compare — they don't conflict.
+
+## ID extraction
+
+Uses site adapters, URL text, and the page title plus ID normalizers. Common title forms include:
+- `MILK-257` → `MILK-257`
+- `MILK257` → `MILK-257`
+- `Some site - MILK-257 [4K]` → `MILK-257`
+
+## Search behavior
+
+By default the extension passes `--quick` to rc-jav (single-ID live `rclone lsjson --include`, ~1–2s, fresh data, no cache). Uncheck **Use --quick mode** in options to use the cache (faster on warm cache, may be stale).
+
+## Files
+
+```
+manifest.json             MV3 manifest
+background.js             service worker, native-messaging port, triggers
+content.js                page extraction, element picker, and in-page overlays
+popup.html / .css / .js   click-the-icon UI
+options.html / .js        trigger toggles + known-site patterns
+icons/                    extension icons
+host/
+  rcjav-host.py           native messaging host (length-prefixed JSON)
+  rcjav-host.bat          shim so the manifest path is stable
+  install-host.ps1        writes the manifest into Brave's NM dir
+  register-host.bat       prompts for ID, calls install-host.ps1
+  com.rcjav.host.json     generated by install-host.ps1 (UTF-8 no BOM)
+  logs/                   host logs and delete audit log
+  state/                  scan progress state
+docs/
+  INSTALL.md              setup guide
+  README.md               this file
+  EXTENSION_ID.md         extension ID stability notes
+```
+
+## Security
+
+- The host manifest's `allowed_origins` is pinned to your extension ID. Only that extension can connect.
+- No network ports opened.
+- Host only spawns `python rc-jav.py …`; no shell, no arbitrary code execution.
+
+## Troubleshooting
+
+Quick reference — full troubleshooting in [`INSTALL.md`](./INSTALL.md#troubleshooting).
+
+- Badge `?` → no JAV ID in title.
+- Badge `!` → host error. Read `host\logs\rcjav-host-stderr.log`.
+- "host unreachable" → re-run `install-host.ps1`, fully restart Brave.
diff --git a/host/com.rcjav.host.json b/host/com.rcjav.host.json
new file mode 100644
index 0000000..f28227d
--- /dev/null
+++ b/host/com.rcjav.host.json
@@ -0,0 +1,9 @@
+{
+  "name": "com.rcjav.host",
+  "description": "rclonex native messaging host (rc-jav bridge)",
+  "path": "D:\\DEV\\Extensions\\Production\\rclone-jav\\host\\rcjav-host.bat",
+  "type": "stdio",
+  "allowed_origins": [
+    "chrome-extension://afbnfamppannbmhgphbbgdkmilijfagp/"
+  ]
+}
diff --git a/host/com.rcjav.host.json.template b/host/com.rcjav.host.json.template
new file mode 100644
index 0000000..f25c542
--- /dev/null
+++ b/host/com.rcjav.host.json.template
@@ -0,0 +1,9 @@
+{
+  "name": "com.rcjav.host",
+  "description": "rclonex native messaging host (rc-jav bridge)",
+  "path": "__HOST_BAT__",
+  "type": "stdio",
+  "allowed_origins": [
+    "chrome-extension://__EXTENSION_ID__/"
+  ]
+}
diff --git a/host/install-host.ps1 b/host/install-host.ps1
new file mode 100644
index 0000000..eeb78c3
--- /dev/null
+++ b/host/install-host.ps1
@@ -0,0 +1,75 @@
+# install-host.ps1
+# Registers rclonex native-messaging host so Brave can launch it.
+#
+# Usage:  .\install-host.ps1 -ExtensionId <id-from-brave://extensions>
+#
+# Writes manifest to host\com.rcjav.host.json with the correct path + extension ID baked in,
+# then registers it in HKLM (requires admin - script self-elevates if needed) AND HKCU.
+# HKLM is required on some Brave installs; HKCU alone is not always honored.
+
+param(
+    [Parameter(Mandatory = $true)]
+    [string]$ExtensionId
+)
+
+$ErrorActionPreference = "Stop"
+
+$hostDir = $PSScriptRoot
+$batPath = Join-Path $hostDir "rcjav-host.bat"
+if (-not (Test-Path $batPath)) { throw "Host bat not found: $batPath" }
+
+$manifestPath = Join-Path $hostDir "com.rcjav.host.json"
+$template = Join-Path $hostDir "com.rcjav.host.json.template"
+if (-not (Test-Path $template)) { throw "Template not found: $template" }
+
+$content = Get-Content $template -Raw
+$content = $content.Replace("__HOST_BAT__", ($batPath -replace "\\", "\\"))
+$content = $content.Replace("__EXTENSION_ID__", $ExtensionId)
+
+# UTF-8 WITHOUT BOM - Chrome/Brave rejects manifests with a BOM.
+[System.IO.File]::WriteAllText($manifestPath, $content, [System.Text.UTF8Encoding]::new($false))
+Write-Host "Manifest written: $manifestPath"
+
+# Self-elevate for HKLM if not already admin.
+$isAdmin = ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole(
+    [Security.Principal.WindowsBuiltInRole]::Administrator)
+if (-not $isAdmin) {
+    Write-Host "Not running as admin - relaunching elevated to write HKLM..."
+    Start-Process pwsh -Verb RunAs -ArgumentList @(
+        "-NoProfile", "-ExecutionPolicy", "Bypass",
+        "-File", $PSCommandPath,
+        "-ExtensionId", $ExtensionId
+    )
+    exit
+}
+
+# Register in HKLM - required on some Brave installs.
+$keys = @(
+    'HKLM:\Software\BraveSoftware\Brave-Browser\NativeMessagingHosts\com.rcjav.host',
+    'HKLM:\Software\Google\Chrome\NativeMessagingHosts\com.rcjav.host',
+    'HKLM:\Software\WOW6432Node\Google\Chrome\NativeMessagingHosts\com.rcjav.host',
+    'HKLM:\Software\Chromium\NativeMessagingHosts\com.rcjav.host',
+    # HKCU as belt-and-suspenders for installs that prefer it
+    'HKCU:\Software\BraveSoftware\Brave-Browser\NativeMessagingHosts\com.rcjav.host',
+    'HKCU:\Software\Google\Chrome\NativeMessagingHosts\com.rcjav.host',
+    'HKCU:\Software\Chromium\NativeMessagingHosts\com.rcjav.host'
+)
+foreach ($k in $keys) {
+    try {
+        New-Item -Path $k -Force -ErrorAction Stop | Out-Null
+        Set-Item -Path $k -Value $manifestPath
+        Write-Host "  Set: $k"
+    } catch {
+        Write-Host "  FAILED: $k  ($($_.Exception.Message))"
+    }
+}
+
+Write-Host ""
+Write-Host "Manifest contents:"
+Write-Host "-------------------"
+Write-Host $content
+Write-Host "-------------------"
+Write-Host ""
+Write-Host "Fully restart Brave (kill all brave.exe processes, then reopen) for the registry"
+Write-Host "entries to be picked up. Then click rclonex toolbar > Ping host."
+Read-Host "Press Enter to close"
diff --git a/host/rcjav-host.bat b/host/rcjav-host.bat
new file mode 100644
index 0000000..9e2113c
--- /dev/null
+++ b/host/rcjav-host.bat
@@ -0,0 +1,8 @@
+@echo off
+REM Portable: uses Windows py launcher if present, falls back to python on PATH.
+REM Stderr redirected to log file so it can't pollute stdout (native messaging is binary).
+setlocal
+set "PYBIN=python"
+where py >nul 2>&1 && set "PYBIN=py"
+if not exist "%~dp0logs" mkdir "%~dp0logs"
+"%PYBIN%" -u "%~dp0rcjav-host.py" 2>>"%~dp0logs\rcjav-host-stderr.log"
diff --git a/host/rcjav-host.log b/host/rcjav-host.log
new file mode 100644
index 0000000..1874dd0
--- /dev/null
+++ b/host/rcjav-host.log
@@ -0,0 +1 @@
+stdin closed, exiting
diff --git a/host/rcjav-host.py b/host/rcjav-host.py
new file mode 100644
index 0000000..75cb738
--- /dev/null
+++ b/host/rcjav-host.py
@@ -0,0 +1,2041 @@
+#!/usr/bin/env python3
+"""Native messaging host for rclonex Brave extension.
+
+Reads length-prefixed JSON messages on stdin, dispatches to rc-jav.py, writes
+length-prefixed JSON responses on stdout. Long-lived: Brave keeps this process
+alive for the lifetime of the extension's connectNative() port.
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import struct
+import subprocess
+import sys
+import threading
+import time
+import traceback
+from datetime import datetime
+from pathlib import Path
+
+# Native messaging requires raw binary stdio. Without this, Windows translates
+# CRLF on stdout (corrupting the 4-byte length prefix) and may buffer.
+if os.name == "nt":
+    import msvcrt
+    msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
+    msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
+
+# ----- config -----
+RC_JAV = Path(r"D:\DEV\Project\rclone-jav\rc-jav.py")
+PYTHON = "python"   # or absolute path to python.exe
+HOST_DIR = Path(__file__).resolve().parent
+LOG_DIR = HOST_DIR / "logs"
+STATE_DIR = HOST_DIR / "state"
+LOG_DIR.mkdir(exist_ok=True)
+STATE_DIR.mkdir(exist_ok=True)
+LOG_FILE = LOG_DIR / "rcjav-host.log"
+EVENTS_LOG = LOG_DIR / "rcjav-host-events.log"
+DELETE_LOG = LOG_DIR / "deletes.log"
+EVENTS_MAX_BYTES = 5 * 1024 * 1024  # 5 MiB — rotate by truncating oldest half
+SCAN_STATE_FILE = STATE_DIR / "scan-state.json"
+VERSION = "0.1.0"
+
+# Scan background thread state
+_scan_lock = threading.Lock()
+_scan_thread: threading.Thread | None = None
+_scan_script_path: Path | None = None   # set by handle_scan; used by handle_scan_cancel
+_scan_proc: subprocess.Popen | None = None
+_scan_cancel_requested = False
+
+HIT_RE = re.compile(r"\[(?P<id>[^\]]+)\] (?P<count>\d+) hit\(s\)")
+MISS_RE = re.compile(r"\[(?P<id>[^\]]+)\] NOT FOUND")
+PRIMARY_ID_RE = re.compile(r"^([A-Za-z]+)-(\d+)")
+FALLBACK_ID_RE = re.compile(r"^([A-Za-z0-9]+)-(\d+)")
+COMPOUND_ID_RE = re.compile(r"^([A-Za-z0-9]+(?:-[A-Za-z0-9]+)+)-(\d+)")
+HOST_RANGE_RE = re.compile(r"\[(\d+)-(\d+)\]")
+
+_cache_lock = threading.Lock()
+_cache_mem: dict[str, dict] = {}
+
+
+def log(msg: str) -> None:
+    try:
+        with LOG_FILE.open("a", encoding="utf-8") as f:
+            f.write(msg + "\n")
+    except OSError:
+        pass
+
+
+def log_event(action: str, **kwargs) -> None:
+    """Append a structured JSON-lines event to rcjav-host-events.log.
+    Rotates by dropping the oldest half when the file exceeds EVENTS_MAX_BYTES."""
+    entry = {"ts": datetime.now().isoformat(), "action": action, **kwargs}
+    line = json.dumps(entry, ensure_ascii=False) + "\n"
+    try:
+        size = EVENTS_LOG.stat().st_size if EVENTS_LOG.exists() else 0
+        if size >= EVENTS_MAX_BYTES:
+            try:
+                raw = EVENTS_LOG.read_bytes()
+                mid = len(raw) // 2
+                # Seek forward to the next newline boundary so we don't split a JSON line.
+                nl = raw.find(b"\n", mid)
+                raw = raw[nl + 1:] if nl >= 0 else raw[mid:]
+                EVENTS_LOG.write_bytes(raw)
+            except OSError:
+                pass
+        with EVENTS_LOG.open("a", encoding="utf-8") as f:
+            f.write(line)
+    except OSError:
+        pass
+
+
+# ----- stdio framing -----
+def read_message():
+    raw_len = sys.stdin.buffer.read(4)
+    if len(raw_len) < 4:
+        return None
+    (msg_len,) = struct.unpack("<I", raw_len)
+    raw = sys.stdin.buffer.read(msg_len)
+    if len(raw) < msg_len:
+        return None
+    return json.loads(raw.decode("utf-8"))
+
+
+# Chrome native messaging caps host->extension messages at 1 MiB. Stay below.
+MAX_RESPONSE_BYTES = 900_000
+
+
+def _shrink_response(obj: dict) -> dict:
+    """If the JSON payload would exceed Chrome's native-messaging cap, drop the
+    heaviest optional fields and add a `truncated` flag so the extension can
+    report it. Last resort: cap `structured` to the first N entries."""
+    data = json.dumps(obj).encode("utf-8")
+    if len(data) <= MAX_RESPONSE_BYTES:
+        return obj
+    shrunk = dict(obj)
+    truncated_reason = []
+    for field in ("raw_json", "stdout", "stderr"):
+        if field in shrunk and shrunk.get(field):
+            shrunk[field] = None
+            truncated_reason.append(f"dropped {field}")
+            if len(json.dumps(shrunk).encode("utf-8")) <= MAX_RESPONSE_BYTES:
+                shrunk["truncated"] = True
+                shrunk["truncated_reason"] = "; ".join(truncated_reason)
+                return shrunk
+    structured = shrunk.get("structured") or []
+    # Set the truncated metadata before sizing so the budget includes it.
+    shrunk["truncated"] = True
+    shrunk["truncated_reason"] = "; ".join(truncated_reason + ["structured TBD"])
+    if structured:
+        lo, hi = 0, len(structured)
+        while lo < hi:
+            mid = (lo + hi + 1) // 2
+            shrunk["structured"] = structured[:mid]
+            if len(json.dumps(shrunk).encode("utf-8")) <= MAX_RESPONSE_BYTES:
+                lo = mid
+            else:
+                hi = mid - 1
+        shrunk["structured"] = structured[:lo]
+        truncated_reason.append(f"structured {len(structured)} -> {lo}")
+    shrunk["truncated_reason"] = "; ".join(truncated_reason)
+    return shrunk
+
+
+def write_message(obj: dict) -> None:
+    obj = _shrink_response(obj)
+    data = json.dumps(obj).encode("utf-8")
+    sys.stdout.buffer.write(struct.pack("<I", len(data)))
+    sys.stdout.buffer.write(data)
+    sys.stdout.buffer.flush()
+
+
+_JSON_DECODER = json.JSONDecoder()
+
+
+def extract_json_blob(text: str) -> dict | None:
+    """Find the last top-level JSON object in `text`. Tolerates leading status
+    lines printed by rc-jav, pretty-printed multi-line JSON, and trailing noise."""
+    if not text:
+        return None
+    last = None
+    i = 0
+    n = len(text)
+    while i < n:
+        j = text.find("{", i)
+        if j < 0:
+            break
+        try:
+            obj, end = _JSON_DECODER.raw_decode(text, j)
+        except json.JSONDecodeError:
+            i = j + 1
+            continue
+        if isinstance(obj, dict):
+            last = obj
+        i = end
+    return last
+
+
+# ----- rc-jav invocation -----
+def resolve_rcjav(rcjav_path: str | None) -> Path:
+    """Accept either a folder (auto-append rc-jav.py) or a full .py path."""
+    if not rcjav_path:
+        return RC_JAV
+    p = Path(rcjav_path)
+    if p.is_dir() or p.suffix.lower() != ".py":
+        p = p / "rc-jav.py"
+    return p
+
+
+def run_rcjav(args: list[str], timeout: int = 120, extra_flags: list[str] | None = None, rcjav_path: str | None = None, stdin_data: str | None = None) -> tuple[int, str, str]:
+    flags = extra_flags if extra_flags is not None else ["--basic", "--no-color"]
+    script = resolve_rcjav(rcjav_path)
+    # Reject up-front instead of resolving a relative path against the host's
+    # CWD (which is whatever Brave hands it — usually its install dir) and
+    # surfacing a confusing "file not found" from subprocess.
+    if not script.is_absolute() or not script.exists():
+        return 2, "", (
+            f"rc-jav.py not found at {script!s} — set the 'rc-jav path' in the "
+            f"extension options to an absolute path that points to rc-jav.py "
+            f"or its parent folder."
+        )
+    cmd = [PYTHON, str(script), *args, *flags]
+    # Hide console window on Windows
+    creationflags = 0
+    if os.name == "nt":
+        creationflags = 0x08000000  # CREATE_NO_WINDOW
+    try:
+        proc = subprocess.run(
+            cmd, capture_output=True, text=True, timeout=timeout,
+            encoding="utf-8", errors="replace",
+            creationflags=creationflags,
+            input=stdin_data,
+        )
+        return proc.returncode, proc.stdout, proc.stderr
+    except subprocess.TimeoutExpired:
+        return 124, "", "timeout after %ds" % timeout
+    except Exception as e:
+        return 1, "", f"spawn error: {e}"
+
+
+def part_pattern_args(payload: dict) -> list[str]:
+    args: list[str] = []
+    for pattern in payload.get("part_patterns") or []:
+        if isinstance(pattern, str) and pattern.strip():
+            args += ["--part-pattern", pattern.strip()]
+    return args
+
+
+def parse_hits(stdout: str) -> tuple[int, list[str]]:
+    """Sum 'N hit(s)' lines, collect IDs."""
+    total = 0
+    ids: list[str] = []
+    for m in HIT_RE.finditer(stdout):
+        total += int(m.group("count"))
+        ids.append(m.group("id"))
+    return total, ids
+
+
+def host_human_size(n: int) -> str:
+    nf = float(n or 0)
+    for unit in ("B", "KiB", "MiB", "GiB", "TiB"):
+        if nf < 1024:
+            return f"{int(nf)} B" if unit == "B" else f"{nf:.2f} {unit}"
+        nf /= 1024
+    return f"{nf:.2f} PiB"
+
+
+def host_normalize_id(raw: str) -> str | None:
+    stem = Path(str(raw) + ".x").stem
+    m = PRIMARY_ID_RE.match(stem) or COMPOUND_ID_RE.match(stem) or FALLBACK_ID_RE.match(stem)
+    if not m:
+        return None
+    num = int(m.group(2))
+    width = max(3, len(m.group(2)))
+    prefix = m.group(1).upper()
+    if prefix == "FC2":
+        prefix = "FC2-PPV"
+    return f"{prefix}-{num:0{width}d}"
+
+
+def _load_rcjav_config(script: Path) -> dict:
+    cfg_path = script.parent / "config.json"
+    if not cfg_path.exists():
+        return {}
+    try:
+        return json.loads(cfg_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def _cache_age_label(scanned_at: str, stale_hours: float = 24) -> tuple[str, bool]:
+    try:
+        dt = datetime.fromisoformat(str(scanned_at).replace("Z", "+00:00"))
+        now = datetime.now(dt.tzinfo) if dt.tzinfo else datetime.now()
+        hours = (now - dt).total_seconds() / 3600.0
+    except Exception:
+        return "?", False
+    if hours < 1:
+        age = f"{int(hours * 60)}m"
+    elif hours < 24:
+        age = f"{hours:.1f}h"
+    else:
+        age = f"{hours / 24:.1f}d"
+    return age, hours > stale_hours
+
+
+def _load_host_cache(script: Path) -> tuple[dict | None, dict]:
+    cache_path = script.parent / "cache.json"
+    timings: dict[str, int | str | bool | None] = {"host_cache_path": str(cache_path)}
+    if not cache_path.exists():
+        timings["host_cache_error"] = "cache.json not found"
+        return None, timings
+    try:
+        stat = cache_path.stat()
+    except OSError as e:
+        timings["host_cache_error"] = str(e)
+        return None, timings
+    key = str(cache_path.resolve())
+    stamp = (stat.st_mtime_ns, stat.st_size)
+    with _cache_lock:
+        cached = _cache_mem.get(key)
+        if cached and cached.get("stamp") == stamp:
+            timings["cache_load_ms"] = 0
+            timings["host_cache_reused"] = True
+            return cached["data"], timings
+    t0 = time.perf_counter()
+    try:
+        data = json.loads(cache_path.read_text(encoding="utf-8"))
+    except Exception as e:
+        timings["cache_load_ms"] = round((time.perf_counter() - t0) * 1000)
+        timings["host_cache_error"] = str(e)
+        return None, timings
+    timings["cache_load_ms"] = round((time.perf_counter() - t0) * 1000)
+    timings["host_cache_reused"] = False
+    with _cache_lock:
+        _cache_mem[key] = {"stamp": stamp, "data": data}
+    return data, timings
+
+
+def _entry_to_hit(source: str, remote: str, item: dict, match_trace: dict | None = None) -> dict:
+    path = item.get("path", "")
+    sep = "" if remote.endswith("/") or not path else "/"
+    size = int(item.get("size") or 0)
+    hit = {
+        "source": source,
+        "remote": remote,
+        "path": path,
+        "full_path": f"{remote}{sep}{path}",
+        "size": size,
+        "size_human": host_human_size(size),
+        "mod_time": item.get("mod_time", ""),
+        "jav_id": item.get("jav_id", ""),
+    }
+    if match_trace:
+        hit.update(match_trace)
+    return hit
+
+
+def _no_match_state(search_mode: str, cache_meta: dict) -> dict:
+    meta = list((cache_meta or {}).values())
+    missing = [m for m in meta if m.get("age") == "missing"]
+    stale = [m for m in meta if m.get("stale")]
+    if search_mode == "quick":
+        return {
+            "no_match_kind": "live_miss",
+            "no_match_title": "Live search found no library hit",
+            "no_match_detail": "The ID was extracted and searched against rclone directly.",
+        }
+    if missing:
+        return {
+            "no_match_kind": "cache_missing",
+            "no_match_title": "Cache search has missing roots",
+            "no_match_detail": "At least one requested root is not present in cache.json. Rebuild or refresh that cache root.",
+        }
+    if stale:
+        return {
+            "no_match_kind": "cache_stale_miss",
+            "no_match_title": "Stale cache found no library hit",
+            "no_match_detail": "The ID was searched in cache, but one or more cache roots are stale.",
+        }
+    return {
+        "no_match_kind": "cache_miss",
+        "no_match_title": "Cache search found no library hit",
+        "no_match_detail": "The ID was extracted and searched in the current cache.",
+    }
+
+
+def handle_cached_search_fast(payload: dict) -> dict | None:
+    """Answer simple cached ID searches in-process, avoiding per-query Python startup.
+    Returns None when the regular rc-jav CLI path should handle the request."""
+    query = payload.get("id") or payload.get("query")
+    if not query or payload.get("name") or payload.get("quick"):
+        return None
+    raw = str(query)
+    if "*" in raw or "?" in raw or HOST_RANGE_RE.search(raw):
+        return None
+    norm = host_normalize_id(raw)
+    if not norm:
+        return None
+
+    t0 = time.perf_counter()
+    script = resolve_rcjav(payload.get("rcjav_path"))
+    cache, timings = _load_host_cache(script)
+    if not isinstance(cache, dict) or not isinstance(cache.get("remotes"), dict):
+        return None
+    cfg = _load_rcjav_config(script)
+    source_roots = [r for r in (payload.get("source_override") or []) if isinstance(r, str)]
+    target_roots = [r for r in (payload.get("target_override") or []) if isinstance(r, str)]
+    if not source_roots and not target_roots:
+        target_roots = cfg.get("default_target") or []
+    if not source_roots and not target_roots:
+        return None
+
+    wanted: list[tuple[str, str]] = [("Source", r) for r in source_roots] + [("Target", r) for r in target_roots]
+    cache_meta: dict[str, dict] = {}
+    hits: list[dict] = []
+    index_start = time.perf_counter()
+    for source, remote in wanted:
+        entry = cache["remotes"].get(remote)
+        if not isinstance(entry, dict):
+            cache_meta[remote] = {"cached": False, "age": "missing", "stale": True, "file_count": 0}
+            continue
+        files = entry.get("files", []) or []
+        age, stale = _cache_age_label(entry.get("scanned_at", ""), _stale_hours(payload))
+        cache_meta[remote] = {"cached": True, "age": age, "stale": stale, "file_count": len(files)}
+        for item in files:
+            jid = item.get("jav_id", "")
+            if jid == norm or str(jid).startswith(norm + "#part"):
+                is_part = str(jid).startswith(norm + "#part")
+                normalized = str(raw).upper() != norm.upper()
+                hits.append(_entry_to_hit(source, remote, item, {
+                    "match_kind": "part" if is_part else "normalized" if normalized else "exact",
+                    "match_reason": "Base ID + part" if is_part else "Normalized ID" if normalized else "Exact ID",
+                    "match_confidence": "related" if is_part else "normalized" if normalized else "high",
+                    "matched_query": norm,
+                    "matched_id": jid,
+                }))
+    timings["cache_match_ms"] = round((time.perf_counter() - index_start) * 1000)
+    hits.sort(key=lambda h: (h.get("jav_id", ""), h.get("path", "").lower()))
+    host_ms = round((time.perf_counter() - t0) * 1000)
+    timings.update({
+        "host_cached_ms": host_ms,
+        "host_rcjav_ms": 0,
+        "cli_elapsed_ms": None,
+    })
+    result = {
+        "ok": True,
+        "rc": 0 if hits else 1,
+        "hits": len(hits),
+        "found": bool(hits),
+        "search_mode": "cached",
+        "structured": hits,
+        "cache_meta": cache_meta,
+        "scanned_remotes": list(cache_meta.keys()),
+        "timings": timings,
+        "stderr": "",
+        "id": query,
+        "name": None,
+        "message": f"{len(hits)} hit(s)" if hits else "NOT FOUND",
+        "fast_path": "host-cache",
+    }
+    if not hits:
+        result.update(_no_match_state("cached", cache_meta))
+    return result
+
+
+# ----- dispatch -----
+def handle_search(payload: dict) -> dict:
+    query = payload.get("id") or payload.get("query")
+    name = payload.get("name")
+    quick = bool(payload.get("quick"))
+    fast = handle_cached_search_fast(payload)
+    if fast is not None:
+        return fast
+    args: list[str] = []
+    if query:
+        args += ["--search", str(query)]
+    if name:
+        args += ["--name", str(name)]
+    if quick:
+        args.append("--quick")
+    args += part_pattern_args(payload)
+    if not args:
+        return {"ok": False, "error": "no id or name"}
+    # Optional profile overrides: --source / --target lists from the active profile.
+    for r in payload.get("source_override") or []:
+        if r and isinstance(r, str):
+            args += ["--source", r]
+    for r in payload.get("target_override") or []:
+        if r and isinstance(r, str):
+            args += ["--target", r]
+    # Always ask for JSON output — needed for per-hit Delete UI in the extension.
+    # Also run --basic to suppress rich on stderr.
+    t0 = time.perf_counter()
+    rc, out, err = run_rcjav(args, extra_flags=["--basic", "--no-color", "--format", "json"], rcjav_path=payload.get("rcjav_path"))
+    rcjav_ms = round((time.perf_counter() - t0) * 1000)
+    parsed = extract_json_blob(out)
+    hits = 0
+    structured: list[dict] = []
+    cache_meta = {}
+    if parsed:
+        for q in parsed.get("queries", []):
+            for h in q.get("hits", []):
+                structured.append(h)
+        structured.extend(parsed.get("name_matches", []))
+        cache_meta = parsed.get("cache_meta", {}) or {}
+        hits = len(structured)
+    else:
+        # Fallback: text count (also covers --basic non-JSON output)
+        hits_count_only, _ = parse_hits(out)
+        hits = hits_count_only
+    # If rc-jav failed and produced no parseable result, surface as an error
+    # instead of an empty "NOT FOUND" — otherwise host crashes look like misses.
+    if rc != 0 and parsed is None and hits == 0:
+        return {
+            "ok": False,
+            "rc": rc,
+            "error": (err or out or "rc-jav exited non-zero").strip()[:1000],
+            "id": query,
+            "name": name,
+        }
+    result = {
+        "ok": True,
+        "rc": rc,
+        "hits": hits,
+        "found": hits > 0,
+        "search_mode": "quick" if quick else "cached",
+        "structured": structured,
+        "cache_meta": cache_meta,
+        "scanned_remotes": list(cache_meta.keys()),
+        "timings": {
+            "host_rcjav_ms": rcjav_ms,
+            "cli_elapsed_ms": round(float(parsed.get("elapsed_sec", 0)) * 1000) if parsed else None,
+            **(parsed.get("timings", {}) if parsed else {}),
+        },
+        # Drop full stdout from the success payload — it duplicates `structured`
+        # (the parsed JSON blob) and can blow Chrome's 1 MiB message cap.
+        "stderr": (err or "")[:2000],
+        "id": query,
+        "name": name,
+        "message": f"{hits} hit(s)" if hits > 0 else "NOT FOUND",
+    }
+    if hits == 0:
+        result.update(_no_match_state("quick" if quick else "cached", cache_meta))
+    return result
+
+
+def handle_bulk_search(payload: dict) -> dict:
+    queries = [
+        str(q).strip() for q in (payload.get("queries") or [])
+        if isinstance(q, str) and str(q).strip()
+    ][:250]
+    if not queries:
+        return {"ok": False, "error": "bulk search needs one or more IDs"}
+    quick = bool(payload.get("quick"))
+    args: list[str] = []
+    for query in queries:
+        args += ["--search", query]
+    if quick:
+        args.append("--quick")
+    args += part_pattern_args(payload)
+    for r in payload.get("source_override") or []:
+        if r and isinstance(r, str):
+            args += ["--source", r]
+    for r in payload.get("target_override") or []:
+        if r and isinstance(r, str):
+            args += ["--target", r]
+    t0 = time.perf_counter()
+    rc, out, err = run_rcjav(
+        args,
+        extra_flags=["--basic", "--no-color", "--format", "json"],
+        rcjav_path=payload.get("rcjav_path"),
+    )
+    rcjav_ms = round((time.perf_counter() - t0) * 1000)
+    parsed = extract_json_blob(out)
+    if parsed is None:
+        return {"ok": False, "rc": rc, "error": (err or out or "bulk search failed").strip()[:1000]}
+    cache_meta = parsed.get("cache_meta", {}) or {}
+    grouped = []
+    total_hits = 0
+    search_mode = "quick" if quick else "cached"
+    for item in parsed.get("queries", []):
+        hits = item.get("hits", []) or []
+        total_hits += len(hits)
+        row = {"query": item.get("query", ""), "hits": len(hits), "structured": hits}
+        if not hits:
+            row.update(_no_match_state(search_mode, cache_meta))
+        grouped.append(row)
+    return {
+        "ok": True,
+        "rc": rc,
+        "search_mode": search_mode,
+        "queries": grouped,
+        "query_count": len(grouped),
+        "hits": total_hits,
+        "cache_meta": cache_meta,
+        "scanned_remotes": list(cache_meta.keys()),
+        "timings": {
+            "host_rcjav_ms": rcjav_ms,
+            "cli_elapsed_ms": round(float(parsed.get("elapsed_sec", 0)) * 1000),
+            **(parsed.get("timings", {}) or {}),
+        },
+        "stderr": (err or "")[:2000],
+    }
+
+
+def handle_dupe_review(payload: dict) -> dict:
+    script = resolve_rcjav(payload.get("rcjav_path"))
+    cfg = _load_rcjav_config(script)
+    source_roots = [r for r in (payload.get("source_override") or []) if isinstance(r, str)]
+    target_roots = [r for r in (payload.get("target_override") or []) if isinstance(r, str)]
+    if not source_roots and not target_roots:
+        target_roots = cfg.get("default_target") or []
+    args = ["--cache"]
+    args += part_pattern_args(payload)
+    for root in source_roots:
+        args += ["--source", root]
+    for root in target_roots:
+        args += ["--target", root]
+    if not source_roots and not target_roots:
+        return {"ok": False, "error": "no source or target roots configured for duplicate review"}
+    t0 = time.perf_counter()
+    rc, out, err = run_rcjav(
+        args,
+        extra_flags=["--basic", "--no-color", "--format", "json"],
+        rcjav_path=payload.get("rcjav_path"),
+    )
+    elapsed = round((time.perf_counter() - t0) * 1000)
+    parsed = extract_json_blob(out)
+    if parsed is None:
+        return {"ok": False, "rc": rc, "error": (err or out or "duplicate review failed").strip()[:1000]}
+    groups = parsed.get("groups", {}) or {}
+    reclaim = sum(
+        int(item.get("size") or 0)
+        for group in groups.values()
+        for item in group.get("delete_candidates", []) or []
+    )
+    return {
+        "ok": True,
+        "groups": groups,
+        "group_count": len(groups),
+        "variant_alerts": parsed.get("variant_alerts", []) or [],
+        "roots": {"source": source_roots, "target": target_roots},
+        "potential_reclaim": reclaim,
+        "potential_reclaim_human": host_human_size(reclaim),
+        "timings": {"host_rcjav_ms": elapsed},
+        "stderr": (err or "")[:2000],
+    }
+
+
+def handle_library_issues(payload: dict) -> dict:
+    """Return non-canonical filenames from cache (bracket-wrapped IDs, no-hyphen IDs)."""
+    script = resolve_rcjav(payload.get("rcjav_path"))
+    t0 = time.perf_counter()
+    rc, out, err = run_rcjav(
+        ["--library-issues"],
+        extra_flags=["--basic", "--no-color", "--format", "json"],
+        rcjav_path=payload.get("rcjav_path"),
+    )
+    elapsed = round((time.perf_counter() - t0) * 1000)
+    parsed = extract_json_blob(out)
+    if parsed is None:
+        return {"ok": False, "rc": rc, "error": (err or out or "library-issues failed").strip()[:1000]}
+    return {
+        "ok": True,
+        "bracket_names": parsed.get("bracket_names", []),
+        "nohyphen_names": parsed.get("nohyphen_names", []),
+        "timings": {"host_rcjav_ms": elapsed},
+    }
+
+
+def _patch_cache_remove_paths(rcjav_path: str | None, full_paths: list[str]) -> None:
+    """Remove file entries from cache.json after successful deletion."""
+    try:
+        script = resolve_rcjav(rcjav_path)
+        cache_path = script.parent / "cache.json"
+        if not cache_path.exists():
+            return
+        cache = json.loads(cache_path.read_text(encoding="utf-8"))
+        # Build set of (remote, rel_path) to remove
+        to_remove: set[tuple[str, str]] = set()
+        for full_path in full_paths:
+            for remote in cache.get("remotes", {}):
+                sep = "" if remote.endswith("/") else "/"
+                prefix = remote + sep
+                if full_path.startswith(prefix):
+                    to_remove.add((remote, full_path[len(prefix):]))
+                    break
+        if not to_remove:
+            return
+        modified = False
+        for remote, remote_data in cache.get("remotes", {}).items():
+            before = len(remote_data.get("files", []))
+            remote_data["files"] = [
+                f for f in remote_data.get("files", [])
+                if (remote, f["path"]) not in to_remove
+            ]
+            if len(remote_data["files"]) != before:
+                modified = True
+        if modified:
+            tmp = cache_path.with_suffix(cache_path.suffix + ".tmp")
+            tmp.write_text(json.dumps(cache, indent=2), encoding="utf-8")
+            os.replace(tmp, cache_path)
+    except Exception as e:
+        log(f"_patch_cache_remove_paths error: {e}")
+
+
+def handle_delete_batch(payload: dict) -> dict:
+    """Delete multiple files respecting existing delete settings, patch cache once."""
+    paths = payload.get("paths") or []
+    if not isinstance(paths, list) or not paths:
+        return {"ok": False, "error": "paths must be a non-empty array"}
+    base = {
+        "mode": payload.get("mode", "trash"),
+        "trash_dir": payload.get("trash_dir", ""),
+        "allowed_remotes": payload.get("allowed_remotes", []),
+        "rcjav_path": payload.get("rcjav_path", ""),
+    }
+    results = []
+    deleted_paths = []
+    for path in paths:
+        r = handle_delete({**base, "path": path})
+        results.append({"path": path, **r})
+        if r.get("ok"):
+            deleted_paths.append(path)
+    if deleted_paths:
+        _patch_cache_remove_paths(payload.get("rcjav_path"), deleted_paths)
+    ok_count = sum(1 for r in results if r.get("ok"))
+    return {
+        "ok": ok_count > 0,
+        "results": results,
+        "deleted_count": ok_count,
+        "failed_count": len(results) - ok_count,
+    }
+
+
+def handle_rename_file(payload: dict) -> dict:
+    """Rename one file in an rclone remote and patch cache. Collision-safe."""
+    remote = (payload.get("remote") or "").strip()
+    old_path = (payload.get("old_path") or "").strip()
+    new_path = (payload.get("new_path") or "").strip()
+    if not remote or not old_path or not new_path:
+        return {"ok": False, "error": "remote, old_path, and new_path are required"}
+    if old_path == new_path:
+        return {"ok": False, "error": "old_path and new_path are identical"}
+    t0 = time.perf_counter()
+    rc, out, err = run_rcjav(
+        ["--rename-file", "--remote", remote, "--old-path", old_path, "--new-path", new_path],
+        extra_flags=["--basic", "--no-color"],
+        rcjav_path=payload.get("rcjav_path"),
+    )
+    elapsed = round((time.perf_counter() - t0) * 1000)
+    parsed = extract_json_blob(out)
+    if parsed is None:
+        return {"ok": False, "rc": rc, "error": (err or out or "rename failed").strip()[:1000]}
+    return {**parsed, "timings": {"host_rcjav_ms": elapsed}}
+
+
+def handle_rename_files_batch(payload: dict) -> dict:
+    """Rename multiple files in one call — single cache write at the end."""
+    renames = payload.get("renames") or []
+    if not isinstance(renames, list) or not renames:
+        return {"ok": False, "error": "renames must be a non-empty array"}
+    t0 = time.perf_counter()
+    rc, out, err = run_rcjav(
+        ["--rename-files-batch"],
+        extra_flags=["--basic", "--no-color"],
+        rcjav_path=payload.get("rcjav_path"),
+        stdin_data=json.dumps(renames),
+    )
+    elapsed = round((time.perf_counter() - t0) * 1000)
+    parsed = extract_json_blob(out)
+    if parsed is None:
+        return {"ok": False, "rc": rc, "error": (err or out or "batch rename failed").strip()[:1000]}
+    return {**parsed, "timings": {"host_rcjav_ms": elapsed}}
+
+
+def _remote_root(p: str) -> str:
+    """Return the `remote:` prefix of an rclone path. For a local path, return ''."""
+    if ":" not in p:
+        return ""
+    return p.split(":", 1)[0] + ":"
+
+
+def _normalize_rclone_prefix(p: str) -> str:
+    """Normalize an allowed rclone path prefix without broadening it to the remote root."""
+    p = (p or "").strip().replace("\\", "/").rstrip("/")
+    return p if ":" in p else ""
+
+
+def _path_in_allowed_prefixes(path: str, prefixes: list[str]) -> bool:
+    path_norm = path.replace("\\", "/")
+    for prefix in prefixes:
+        if path_norm == prefix or path_norm.startswith(prefix + "/"):
+            return True
+    return False
+
+
+def handle_delete(payload: dict) -> dict:
+    """Delete or move-to-trash a single file via rclone."""
+    path = payload.get("path", "").strip()
+    mode = payload.get("mode", "trash")  # 'trash' or 'permanent'
+    trash_dir = payload.get("trash_dir", "").strip()
+    allowed_prefixes = [
+        p for p in (_normalize_rclone_prefix(r) for r in payload.get("allowed_remotes", []))
+        if p
+    ]
+    # Derive additional allowlist from rc-jav's config.json (default_target +
+    # default_source) so the host is self-protective even if the extension forgets
+    # to pass allowed_remotes. Plus the trash_dir itself.
+    script = resolve_rcjav(payload.get("rcjav_path"))
+    cfg_path = script.parent / "config.json"
+    if cfg_path.exists():
+        try:
+            cfg = json.loads(cfg_path.read_text(encoding="utf-8"))
+            for key in ("default_target", "default_source"):
+                for r in cfg.get(key, []) or []:
+                    prefix = _normalize_rclone_prefix(r)
+                    if prefix and prefix not in allowed_prefixes:
+                        allowed_prefixes.append(prefix)
+        except (OSError, json.JSONDecodeError):
+            pass
+    if trash_dir:
+        prefix = _normalize_rclone_prefix(trash_dir)
+        if prefix and prefix not in allowed_prefixes:
+            allowed_prefixes.append(prefix)
+    if not path:
+        return {"ok": False, "error": "no path"}
+    # Reject directory-shaped paths — `rclone moveto` on a trailing-slash path
+    # would move a whole tree and produce a destination with empty leaf.
+    if path.endswith("/") or path.endswith("\\"):
+        return {"ok": False, "error": "path looks like a directory (trailing slash)"}
+    # Sanity: must look like an rclone remote path (contains ':') or a local file
+    if ":" not in path and not Path(path).exists():
+        return {"ok": False, "error": "path doesn't look like an rclone remote or local file"}
+    # Allowlist: refuse to delete anything outside the configured library paths.
+    # Defaults derive from rc-jav config.json + trash_dir above.
+    # If still empty, no config was found — refuse rather than fail-open.
+    if not allowed_prefixes:
+        return {"ok": False, "error": "no allowed prefixes configured; refusing to delete"}
+    root = _remote_root(path)
+    if not root or not _path_in_allowed_prefixes(path, allowed_prefixes):
+        return {
+            "ok": False,
+            "error": f"path {path!r} not in allowed prefixes={allowed_prefixes}",
+        }
+
+    audit = DELETE_LOG
+    log_entry = {"ts": __import__("datetime").datetime.now().isoformat(),
+                 "path": path, "mode": mode, "trash_dir": trash_dir}
+
+    if mode == "permanent":
+        cmd = [RCLONE_BIN, "deletefile", path]
+    elif mode == "trash":
+        if not trash_dir:
+            return {"ok": False, "error": "trash_dir required when mode=trash"}
+        # rclone moveto src dst — preserves filename if dst is dir-like, but for a single
+        # file we should give it a full destination path.
+        from datetime import date
+        date_prefix = date.today().isoformat()
+        leaf = path.split("/")[-1]
+        dst = f"{trash_dir.rstrip('/')}/{date_prefix}/{leaf}"
+        cmd = [RCLONE_BIN, "moveto", path, dst]
+        log_entry["dst"] = dst
+    else:
+        return {"ok": False, "error": f"unknown mode {mode!r}"}
+
+    creationflags = 0x08000000 if os.name == "nt" else 0
+    try:
+        proc = subprocess.run(cmd, capture_output=True, text=True, timeout=300,
+                              encoding="utf-8", errors="replace",
+                              creationflags=creationflags)
+        log_entry["rc"] = proc.returncode
+        log_entry["stderr"] = proc.stderr.strip()[:500]
+    except Exception as e:
+        log_entry["error"] = str(e)
+        try:
+            with audit.open("a", encoding="utf-8") as f:
+                f.write(json.dumps(log_entry) + "\n")
+        except OSError:
+            pass
+        return {"ok": False, "error": str(e)}
+
+    try:
+        with audit.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(log_entry) + "\n")
+    except OSError:
+        pass
+
+    return {
+        "ok": proc.returncode == 0,
+        "rc": proc.returncode,
+        "stdout": proc.stdout,
+        "stderr": proc.stderr,
+        "path": path,
+        "mode": mode,
+        "dst": log_entry.get("dst"),
+    }
+
+
+def handle_recent_deletes(payload: dict) -> dict:
+    """Return the last N successful trash-mode deletes, newest first, so the
+    extension can offer Undo. Permanent deletes are excluded — they can't be
+    undone."""
+    limit = max(1, min(int(payload.get("limit") or 20), 200))
+    audit = DELETE_LOG
+    if not audit.exists():
+        return {"ok": True, "entries": []}
+    # Read tail. deletes.log is line-delimited JSON; small enough to read in full
+    # in practice, but cap defensively at 1 MiB so a runaway log doesn't OOM us.
+    try:
+        raw = audit.read_text(encoding="utf-8", errors="replace")
+        if len(raw) > 1_000_000:
+            raw = raw[-1_000_000:]
+    except OSError as e:
+        return {"ok": False, "error": f"can't read deletes.log: {e}"}
+    out: list[dict] = []
+    for line in raw.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            obj = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        # Skip undo records and permanent deletes — neither is undoable.
+        if obj.get("kind") == "undo":
+            continue
+        if obj.get("mode") != "trash":
+            continue
+        if obj.get("rc") != 0:
+            continue
+        if not obj.get("dst"):
+            continue
+        out.append({
+            "ts": obj.get("ts"),
+            "path": obj.get("path"),
+            "dst": obj.get("dst"),
+            "trash_dir": obj.get("trash_dir"),
+        })
+    # Build the set of dst paths already undone so we hide them.
+    undone_dst = set()
+    for line in raw.splitlines():
+        try:
+            obj = json.loads(line)
+        except (json.JSONDecodeError, ValueError):
+            continue
+        if obj.get("kind") == "undo" and obj.get("rc") == 0 and obj.get("dst"):
+            undone_dst.add(obj["dst"])
+    out = [e for e in out if e["dst"] not in undone_dst]
+    out.reverse()  # newest first
+    return {"ok": True, "entries": out[:limit]}
+
+
+def handle_undo_delete(payload: dict) -> dict:
+    """Move a file from trash back to its original path via `rclone moveto`.
+    The extension passes the {dst, path} pair captured in the delete audit log;
+    we re-validate both ends against the configured allowlist before acting."""
+    dst = (payload.get("dst") or "").strip()
+    orig = (payload.get("path") or "").strip()
+    if not dst or not orig:
+        return {"ok": False, "error": "undo needs both dst (trash location) and path (original)"}
+
+    # Reuse the same allowlist derivation handle_delete uses.
+    allowed_prefixes = [
+        p for p in (_normalize_rclone_prefix(r) for r in payload.get("allowed_remotes", []))
+        if p
+    ]
+    script = resolve_rcjav(payload.get("rcjav_path"))
+    cfg_path = script.parent / "config.json"
+    if cfg_path.exists():
+        try:
+            cfg = json.loads(cfg_path.read_text(encoding="utf-8"))
+            for key in ("default_target", "default_source"):
+                for r in cfg.get(key, []) or []:
+                    prefix = _normalize_rclone_prefix(r)
+                    if prefix and prefix not in allowed_prefixes:
+                        allowed_prefixes.append(prefix)
+        except (OSError, json.JSONDecodeError):
+            pass
+    trash_dir = (payload.get("trash_dir") or "").strip()
+    if trash_dir:
+        prefix = _normalize_rclone_prefix(trash_dir)
+        if prefix and prefix not in allowed_prefixes:
+            allowed_prefixes.append(prefix)
+    if not allowed_prefixes:
+        return {"ok": False, "error": "no allowed prefixes configured; refusing to undo"}
+    for end, label in ((dst, "dst"), (orig, "path")):
+        if end.endswith("/") or end.endswith("\\"):
+            return {"ok": False, "error": f"undo {label} looks like a directory"}
+        if ":" not in end:
+            return {"ok": False, "error": f"undo {label} not an rclone path"}
+        if not _path_in_allowed_prefixes(end, allowed_prefixes):
+            return {"ok": False, "error": f"undo {label} {end!r} not in allowed prefixes"}
+
+    creationflags = 0x08000000 if os.name == "nt" else 0
+    cmd = [RCLONE_BIN, "moveto", dst, orig]
+    audit = DELETE_LOG
+    log_entry = {
+        "ts": datetime.now().isoformat(),
+        "kind": "undo",
+        "path": orig,
+        "dst": dst,
+        "trash_dir": trash_dir,
+    }
+    try:
+        proc = subprocess.run(cmd, capture_output=True, text=True, timeout=300,
+                              encoding="utf-8", errors="replace",
+                              creationflags=creationflags)
+        log_entry["rc"] = proc.returncode
+        log_entry["stderr"] = (proc.stderr or "").strip()[:500]
+    except Exception as e:
+        log_entry["error"] = str(e)
+        try:
+            with audit.open("a", encoding="utf-8") as f:
+                f.write(json.dumps(log_entry) + "\n")
+        except OSError:
+            pass
+        return {"ok": False, "error": str(e)}
+    try:
+        with audit.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(log_entry) + "\n")
+    except OSError:
+        pass
+    return {
+        "ok": proc.returncode == 0,
+        "rc": proc.returncode,
+        "stderr": proc.stderr,
+        "path": orig,
+        "dst": dst,
+    }
+
+
+# rclone binary path — assumes on PATH. Override via env if needed.
+RCLONE_BIN = "rclone"
+
+
+def handle_ping(payload: dict) -> dict:
+    override = payload.get("rcjav_path", "")
+    effective = resolve_rcjav(override)
+    return {
+        "ok": True,
+        "version": VERSION,
+        "rc_jav": str(effective),
+        "rc_jav_exists": effective.exists(),
+        "rc_jav_default": str(RC_JAV),
+        "rc_jav_overridden": bool(override),
+        "python": PYTHON,
+    }
+
+
+def handle_diagnostics(payload: dict) -> dict:
+    """Run a battery of environment checks. Returns ordered list of {name, status, detail}."""
+    import shutil
+    checks: list[dict] = []
+
+    def add(name, status, detail=""):
+        checks.append({"name": name, "status": status, "detail": str(detail)})
+
+    # Python
+    add("Python interpreter", "ok", sys.version.split()[0] + " — " + sys.executable)
+
+    # rc-jav script
+    override = payload.get("rcjav_path", "")
+    script = resolve_rcjav(override)
+    add("Host version", "ok", VERSION)
+    add("rc-jav path source", "ok",
+        "extension override: " + override if override else f"host default: {RC_JAV}")
+    if script.exists():
+        add("rc-jav.py", "ok", str(script))
+    else:
+        add("rc-jav.py", "fail", f"not found at {script}")
+
+    ext_settings = payload.get("extension_settings") or {}
+    if isinstance(ext_settings, dict) and ext_settings:
+        mode = "quick/live" if ext_settings.get("quick_mode") else "cache"
+        profile = ext_settings.get("active_profile") or "config.json defaults"
+        profile_count = ext_settings.get("profile_count", 0)
+        triggers = []
+        if ext_settings.get("auto_every_page"):
+            triggers.append("every page")
+        if ext_settings.get("auto_known_sites"):
+            triggers.append("known sites")
+        add("Extension settings", "ok",
+            f"mode={mode}; profile={profile}; profiles={profile_count}; auto={', '.join(triggers) or 'off'}")
+
+    # rc-jav can run --help
+    if script.exists():
+        try:
+            cf = 0x08000000 if os.name == "nt" else 0
+            r = subprocess.run([PYTHON, str(script), "--help"], capture_output=True, text=True, timeout=10, encoding="utf-8", errors="replace", creationflags=cf)
+            if r.returncode == 0:
+                add("rc-jav --help", "ok", "exits 0")
+            else:
+                add("rc-jav --help", "fail", f"exit {r.returncode}: {r.stderr.strip()[:200]}")
+        except Exception as e:
+            add("rc-jav --help", "fail", str(e))
+    else:
+        add("rc-jav --help", "warn", "skipped (script missing)")
+
+    # rich library present?
+    try:
+        if script.exists():
+            cf = 0x08000000 if os.name == "nt" else 0
+            r = subprocess.run([PYTHON, "-c", "import rich; print(rich.__file__)"], capture_output=True, text=True, timeout=10, encoding="utf-8", errors="replace", creationflags=cf)
+            if r.returncode == 0:
+                add("rich (Python pkg)", "ok", r.stdout.strip())
+            else:
+                add("rich (Python pkg)", "fail", "import failed — run: pip install rich")
+    except Exception as e:
+        add("rich (Python pkg)", "fail", str(e))
+
+    # rclone on PATH
+    rclone = shutil.which("rclone") or shutil.which("rclone.exe")
+    if rclone:
+        try:
+            cf = 0x08000000 if os.name == "nt" else 0
+            r = subprocess.run([rclone, "version"], capture_output=True, text=True, timeout=10, encoding="utf-8", errors="replace", creationflags=cf)
+            first = r.stdout.splitlines()[0] if r.stdout else "?"
+            add("rclone binary", "ok", f"{rclone} — {first}")
+        except Exception as e:
+            add("rclone binary", "warn", f"found at {rclone} but version check failed: {e}")
+    else:
+        add("rclone binary", "fail", "not on PATH")
+
+    # Brave config — rclone listremotes
+    if rclone:
+        try:
+            cf = 0x08000000 if os.name == "nt" else 0
+            r = subprocess.run([rclone, "listremotes"], capture_output=True, text=True, timeout=10, encoding="utf-8", errors="replace", creationflags=cf)
+            if r.returncode == 0:
+                remotes = [s.strip() for s in r.stdout.splitlines() if s.strip()]
+                add("rclone remotes", "ok" if remotes else "warn",
+                    ", ".join(remotes) if remotes else "no remotes configured")
+            else:
+                add("rclone remotes", "fail", r.stderr.strip()[:200])
+        except Exception as e:
+            add("rclone remotes", "fail", str(e))
+
+    # rc-jav config.json
+    if script.exists():
+        cfg = script.parent / "config.json"
+        if cfg.exists():
+            try:
+                data = json.loads(cfg.read_text(encoding="utf-8"))
+                tgt = data.get("default_target", [])
+                src = data.get("default_source", [])
+                add("rc-jav config.json", "ok",
+                    f"source={src or '(empty)'}  target={tgt or '(empty)'}")
+            except Exception as e:
+                add("rc-jav config.json", "fail", str(e))
+        else:
+            add("rc-jav config.json", "warn", f"not present at {cfg}")
+
+        # cache.json status
+        cache = script.parent / "cache.json"
+        if cache.exists():
+            try:
+                data = json.loads(cache.read_text(encoding="utf-8"))
+                rmap = data.get("remotes", {})
+                summary = [f"{r}={len(v.get('files', []))} files" for r, v in rmap.items()]
+                add("rc-jav cache.json", "ok", "; ".join(summary) if summary else "empty")
+            except Exception as e:
+                add("rc-jav cache.json", "warn", str(e))
+        else:
+            add("rc-jav cache.json", "warn", "no cache yet (run --scan to build)")
+
+        try:
+            cache_status = handle_cache_status(payload)
+            warnings = cache_status.get("warnings") or []
+            stale = [r["remote"] for r in cache_status.get("remotes", []) if r.get("stale")]
+            if warnings:
+                add("Cache health", "warn", "; ".join((w.get("message") or w.get("code") or "?") for w in warnings[:3]))
+            elif stale:
+                add("Cache health", "warn", "stale remotes: " + ", ".join(stale))
+            elif cache_status.get("cache_exists"):
+                add("Cache health", "ok", "no mismatch warnings")
+        except Exception as e:
+            add("Cache health", "warn", str(e))
+
+        # WinCatalog folder
+        wc = script.parent / "wincatalog"
+        if wc.exists() and wc.is_dir():
+            files = [f.name for f in wc.iterdir() if f.suffix.lower() in (".csv", ".xml")]
+            add("WinCatalog folder", "ok" if files else "info",
+                f"{wc} — {len(files)} CSV/XML file(s)" if files else f"optional: no CSV/XML files in {wc}")
+        else:
+            add("WinCatalog folder", "info", f"optional: not present at {wc}")
+
+    return {"ok": True, "checks": checks}
+
+
+REGISTRY_HOST_KEYS = [
+    (r"HKLM\Software\BraveSoftware\Brave-Browser\NativeMessagingHosts\com.rcjav.host", "HKEY_LOCAL_MACHINE", r"Software\BraveSoftware\Brave-Browser\NativeMessagingHosts\com.rcjav.host"),
+    (r"HKLM\Software\Google\Chrome\NativeMessagingHosts\com.rcjav.host", "HKEY_LOCAL_MACHINE", r"Software\Google\Chrome\NativeMessagingHosts\com.rcjav.host"),
+    (r"HKLM\Software\WOW6432Node\Google\Chrome\NativeMessagingHosts\com.rcjav.host", "HKEY_LOCAL_MACHINE", r"Software\WOW6432Node\Google\Chrome\NativeMessagingHosts\com.rcjav.host"),
+    (r"HKLM\Software\Chromium\NativeMessagingHosts\com.rcjav.host", "HKEY_LOCAL_MACHINE", r"Software\Chromium\NativeMessagingHosts\com.rcjav.host"),
+    (r"HKCU\Software\BraveSoftware\Brave-Browser\NativeMessagingHosts\com.rcjav.host", "HKEY_CURRENT_USER", r"Software\BraveSoftware\Brave-Browser\NativeMessagingHosts\com.rcjav.host"),
+    (r"HKCU\Software\Google\Chrome\NativeMessagingHosts\com.rcjav.host", "HKEY_CURRENT_USER", r"Software\Google\Chrome\NativeMessagingHosts\com.rcjav.host"),
+    (r"HKCU\Software\Chromium\NativeMessagingHosts\com.rcjav.host", "HKEY_CURRENT_USER", r"Software\Chromium\NativeMessagingHosts\com.rcjav.host"),
+]
+
+
+def _registry_host_entries() -> list[dict]:
+    if os.name != "nt":
+        return []
+    try:
+        import winreg
+    except Exception:
+        return [{"key": "registry", "status": "fail", "detail": "winreg unavailable"}]
+    hives = {
+        "HKEY_LOCAL_MACHINE": winreg.HKEY_LOCAL_MACHINE,
+        "HKEY_CURRENT_USER": winreg.HKEY_CURRENT_USER,
+    }
+    entries = []
+    for label, hive_name, subkey in REGISTRY_HOST_KEYS:
+        try:
+            with winreg.OpenKey(hives[hive_name], subkey) as key:
+                value, _ = winreg.QueryValueEx(key, None)
+            entries.append({"key": label, "status": "ok", "manifest": str(value)})
+        except FileNotFoundError:
+            entries.append({"key": label, "status": "missing", "manifest": ""})
+        except PermissionError as e:
+            entries.append({"key": label, "status": "warn", "manifest": "", "detail": str(e)})
+        except OSError as e:
+            entries.append({"key": label, "status": "warn", "manifest": "", "detail": str(e)})
+    return entries
+
+
+def handle_host_status(payload: dict) -> dict:
+    """Check native-messaging registration without writing registry or files."""
+    extension_id = (payload.get("extension_id") or "").strip()
+    expected_origin = f"chrome-extension://{extension_id}/" if extension_id else ""
+    host_dir = Path(__file__).resolve().parent
+    manifest_path = host_dir / "com.rcjav.host.json"
+    install_script = host_dir / "install-host.ps1"
+    batch_path = host_dir / "rcjav-host.bat"
+    checks: list[dict] = []
+
+    def add(name, status, detail=""):
+        checks.append({"name": name, "status": status, "detail": str(detail)})
+
+    if manifest_path.exists():
+        add("Manifest file", "ok", str(manifest_path))
+    else:
+        add("Manifest file", "fail", f"not found at {manifest_path}")
+
+    manifest = {}
+    if manifest_path.exists():
+        try:
+            manifest = json.loads(manifest_path.read_text(encoding="utf-8-sig"))
+            add("Manifest JSON", "ok", "valid JSON")
+        except Exception as e:
+            add("Manifest JSON", "fail", str(e))
+
+    manifest_host_path = manifest.get("path", "") if isinstance(manifest, dict) else ""
+    if manifest_host_path:
+        hp = Path(manifest_host_path)
+        status = "ok" if hp.exists() else "fail"
+        add("Manifest host path", status, manifest_host_path)
+    else:
+        add("Manifest host path", "fail", "missing path")
+
+    origins = manifest.get("allowed_origins", []) if isinstance(manifest, dict) else []
+    if expected_origin:
+        add(
+            "Extension origin",
+            "ok" if expected_origin in origins else "fail",
+            expected_origin if expected_origin in origins else f"expected {expected_origin}; manifest has {origins}",
+        )
+    else:
+        add("Extension origin", "warn", "extension id not supplied")
+
+    registry_entries = _registry_host_entries()
+    matching_registry = [
+        e for e in registry_entries
+        if e.get("manifest") and Path(e["manifest"]).resolve() == manifest_path.resolve()
+    ]
+    registered = [e for e in registry_entries if e.get("status") == "ok"]
+    if matching_registry:
+        add("Registry registration", "ok",
+            f"{len(matching_registry)} matching registry entr{'y' if len(matching_registry) == 1 else 'ies'}\n"
+            + "\n".join(e["key"] for e in matching_registry))
+    elif registered:
+        add("Registry registration", "fail", "registered path differs: " + "; ".join(f"{e['key']} -> {e['manifest']}" for e in registered))
+    else:
+        add("Registry registration", "fail" if os.name == "nt" else "warn", "no matching native host registry entries found")
+
+    if batch_path.exists():
+        add("Host launcher", "ok", str(batch_path))
+    else:
+        add("Host launcher", "fail", str(batch_path))
+
+    has_problem = any(c.get("status") == "fail" for c in checks)
+    add("Repair command", "warn" if has_problem else "info",
+        f"pwsh -ExecutionPolicy Bypass -File \"{install_script}\" -ExtensionId {extension_id or '<extension-id>'}")
+    return {
+        "ok": True,
+        "checks": checks,
+        "registry": registry_entries,
+        "manifest_path": str(manifest_path),
+        "install_script": str(install_script),
+    }
+
+
+def handle_host_repair(payload: dict) -> dict:
+    """Repair the current host manifest and user-level registry entries.
+
+    This is callable only when Brave can already launch this host. Blocked
+    forbidden/not-found states still need the external install script because
+    no native host process exists for the extension to call.
+    """
+    extension_id = (payload.get("extension_id") or "").strip()
+    if not extension_id:
+        return {"ok": False, "error": "extension id is required"}
+    host_dir = Path(__file__).resolve().parent
+    batch_path = host_dir / "rcjav-host.bat"
+    manifest_path = host_dir / "com.rcjav.host.json"
+    if not batch_path.exists():
+        return {"ok": False, "error": f"host launcher not found at {batch_path}"}
+    manifest = {
+        "name": "com.rcjav.host",
+        "description": "rclonex native messaging host (rc-jav bridge)",
+        "path": str(batch_path),
+        "type": "stdio",
+        "allowed_origins": [f"chrome-extension://{extension_id}/"],
+    }
+    try:
+        manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
+    except OSError as e:
+        return {"ok": False, "error": f"failed to write manifest: {e}"}
+
+    registrations = []
+    if os.name == "nt":
+        try:
+            import winreg
+            hkcu_keys = [subkey for _, hive_name, subkey in REGISTRY_HOST_KEYS
+                         if hive_name == "HKEY_CURRENT_USER"]
+            for subkey in hkcu_keys:
+                try:
+                    with winreg.CreateKey(winreg.HKEY_CURRENT_USER, subkey) as key:
+                        winreg.SetValueEx(key, None, 0, winreg.REG_SZ, str(manifest_path))
+                    registrations.append({"key": "HKCU\\" + subkey, "status": "ok"})
+                except OSError as e:
+                    registrations.append({"key": "HKCU\\" + subkey, "status": "fail", "detail": str(e)})
+        except Exception as e:
+            registrations.append({"key": "HKCU registry", "status": "fail", "detail": str(e)})
+
+    verify = handle_host_status({**payload, "extension_id": extension_id})
+    failed = [r for r in registrations if r.get("status") != "ok"]
+    return {
+        "ok": not failed,
+        "manifest_path": str(manifest_path),
+        "registrations": registrations,
+        "verification": verify,
+        "restart_required": True,
+        "message": "manifest and user-level registrations repaired; restart Brave to relaunch the host with the repaired origin",
+    }
+
+
+def _cache_age_hours(scanned_at: str) -> float | None:
+    try:
+        dt = datetime.fromisoformat(scanned_at.replace("Z", "+00:00"))
+    except (ValueError, AttributeError):
+        return None
+    now = datetime.now(dt.tzinfo) if dt.tzinfo else datetime.now()
+    return (now - dt).total_seconds() / 3600.0
+
+
+def _stale_hours(payload: dict) -> float:
+    try:
+        hours = float(payload.get("stale_hours", 24))
+    except (TypeError, ValueError):
+        return 24
+    return min(max(hours, 1), 24 * 365)
+
+
+def _read_scan_state() -> dict:
+    if not SCAN_STATE_FILE.exists():
+        return {}
+    try:
+        state = json.loads(SCAN_STATE_FILE.read_text(encoding="utf-8"))
+        return state if isinstance(state, dict) else {}
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def _apply_scan_status(remotes: list[dict], state: dict) -> None:
+    current = state.get("current_remote")
+    if not current:
+        return
+    status = ""
+    if state.get("scanning") and not state.get("done"):
+        status = "scanning"
+    elif state.get("done") and state.get("scan_ok") is False:
+        status = "failed"
+    if not status:
+        return
+    for remote in remotes:
+        if remote.get("remote") == current:
+            remote["status"] = status
+            remote["stale"] = status == "failed" or remote.get("stale", False)
+            return
+
+
+def _describe_skipped_id(path: str, remote: str = "") -> dict:
+    name = Path(str(path or "").replace("\\", "/")).name
+    ext = Path(name).suffix.lower().lstrip(".")
+    reason = "no supported ID at filename start"
+    if re.match(r"^\[[A-Za-z0-9-]+-\d+\]", name):
+        reason = "leading brackets hide the ID"
+    elif re.match(r"^[A-Za-z][A-Za-z0-9]+[\u2010-\u2015]\d+", name):
+        reason = "non-ASCII dash in ID"
+    elif re.match(r"^[A-Za-z][A-Za-z0-9]+\d+", name):
+        reason = "missing hyphen between prefix and number"
+    sep = "" if not remote or remote.endswith("/") or not path else "/"
+    full_path = f"{remote}{sep}{path}" if remote else path
+    return {"path": path, "name": name, "ext": ext, "reason": reason, "full_path": full_path}
+
+
+def handle_cache_status(payload: dict) -> dict:
+    script = resolve_rcjav(payload.get("rcjav_path", ""))
+    cache_path = script.parent / "cache.json"
+    config_path = script.parent / "config.json"
+    configured = {"default_source": [], "default_target": []}
+    if config_path.exists():
+        try:
+            cfg = json.loads(config_path.read_text(encoding="utf-8"))
+            configured["default_source"] = cfg.get("default_source", []) or []
+            configured["default_target"] = cfg.get("default_target", []) or []
+        except Exception:
+            pass
+    stale_hours = _stale_hours(payload)
+    scan_state = _read_scan_state()
+    configured_roots = set((configured.get("default_source") or []) + (configured.get("default_target") or []))
+    if not cache_path.exists():
+        remotes = [{
+            "remote": remote,
+            "status": "never_scanned",
+            "stale": True,
+            "file_count": 0,
+            "skipped_count": 0,
+            "issues": [],
+        } for remote in sorted(configured_roots)]
+        _apply_scan_status(remotes, scan_state)
+        return {
+            "ok": True,
+            "cache_exists": False,
+            "cache_path": str(cache_path),
+            "configured": configured,
+            "stale_hours": stale_hours,
+            "scan_state": scan_state,
+            "remotes": remotes,
+        }
+    try:
+        data = json.loads(cache_path.read_text(encoding="utf-8"))
+    except Exception as e:
+        return {"ok": False, "error": str(e), "cache_path": str(cache_path)}
+    remotes = []
+    warnings = []
+    remote_map = data.get("remotes", {}) or {}
+    configured_remote_prefixes = {r.split(":", 1)[0] + ":" for r in configured_roots if isinstance(r, str) and ":" in r}
+    cached_remote_prefixes = {r.split(":", 1)[0] + ":" for r in remote_map if isinstance(r, str) and ":" in r}
+    for remote, entry in remote_map.items():
+        files = entry.get("files", []) or []
+        skipped = entry.get("skipped", []) or []
+        scanned_at = entry.get("scanned_at", "")
+        age = _cache_age_hours(scanned_at)
+        bare_fc2 = 0
+        short_number = 0
+        missing_jav_id = 0
+        for f in files:
+            jid = str(f.get("jav_id") or "")
+            if not jid:
+                missing_jav_id += 1
+                continue
+            base = jid.split("#", 1)[0]
+            if re.match(r"^FC2-\d{4,}$", base, re.I):
+                bare_fc2 += 1
+            if re.match(r"^[A-Z][A-Z0-9]{1,}-\d{1,2}$", base, re.I):
+                short_number += 1
+        issues = []
+        if bare_fc2:
+            issues.append({"code": "bare_fc2", "count": bare_fc2, "message": "bare FC2 IDs should now be FC2-PPV"})
+        if short_number:
+            issues.append({"code": "short_number", "count": short_number, "message": "IDs with fewer than 3 digits suggest an old cache"})
+        if missing_jav_id:
+            issues.append({"code": "missing_jav_id", "count": missing_jav_id, "message": "cache rows missing jav_id"})
+        if issues:
+            warnings.append({
+                "remote": remote,
+                "code": "stale_id_shape",
+                "message": f"{remote} contains IDs from older normalization rules; rebuild cache recommended",
+                "issues": issues,
+            })
+        is_stale = bool(age is not None and age > stale_hours)
+        remotes.append({
+            "remote": remote,
+            "status": "stale" if is_stale else "fresh",
+            "scanned_at": scanned_at,
+            "age_hours": round(age, 3) if age is not None else None,
+            "stale": is_stale,
+            "file_count": len(files),
+            "skipped_count": len(skipped),
+            "skipped_items": [_describe_skipped_id(path, remote) for path in skipped],
+            "skipped_samples": [_describe_skipped_id(path, remote) for path in skipped[:5]],
+            "issues": issues,
+        })
+    cached_roots = set(remote_map.keys())
+    for remote in sorted(configured_roots - cached_roots):
+        remotes.append({
+            "remote": remote,
+            "status": "never_scanned",
+            "scanned_at": "",
+            "age_hours": None,
+            "stale": True,
+            "file_count": 0,
+            "skipped_count": 0,
+            "issues": [],
+        })
+        warnings.append({
+            "remote": remote,
+            "code": "remote_not_scanned",
+            "message": f"{remote} is configured but has not been scanned into cache.json",
+        })
+    if configured_remote_prefixes and cached_remote_prefixes and not cached_remote_prefixes.intersection(configured_remote_prefixes):
+        warnings.append({
+            "code": "remote_prefix_mismatch",
+            "message": "cache remotes do not share a remote prefix with config.json defaults",
+            "configured": sorted(configured_roots),
+            "cached": sorted(remote_map.keys()),
+        })
+    for remote in remote_map:
+        if configured_roots and remote not in configured_roots:
+            same_parent = any(remote.startswith(root.rstrip("/") + "/") or root.startswith(remote.rstrip("/") + "/") for root in configured_roots)
+            if not same_parent and remote not in configured_roots:
+                warnings.append({
+                    "remote": remote,
+                    "code": "remote_not_configured",
+                    "message": f"{remote} is in cache.json but is not one of config.json's default source/target roots",
+                })
+    _apply_scan_status(remotes, scan_state)
+    remotes.sort(key=lambda r: r["remote"].lower())
+    return {
+        "ok": True,
+        "cache_exists": True,
+        "cache_path": str(cache_path),
+        "version": data.get("version"),
+        "stale_hours": stale_hours,
+        "configured": configured,
+        "scan_state": scan_state,
+        "remotes": remotes,
+        "warnings": warnings,
+    }
+
+
+def _scan_worker(cmd: list[str], creationflags: int, scan_since: str = "",
+                 scan_roots: list[str] | None = None) -> None:
+    """Background thread: runs rc-jav --scan via Popen, reads stderr line-by-line
+    to parse SCAN_START / SCAN_PROGRESS / 'Scan complete:' lines, and writes
+    live progress to SCAN_STATE_FILE so handle_scan_progress can return it."""
+    global _scan_thread, _scan_proc, _scan_cancel_requested
+    state: dict = {
+        "scanning": True, "done": False,
+        "started_at": datetime.now().isoformat(),
+        "scan_since": scan_since,
+        "scope": list(scan_roots or []),
+        "remotes": [], "total_remotes": 0,
+        "remote_jobs": [],
+        "current_remote": None, "current_label": None,
+        "files_this_remote": 0, "files_total": 0,
+        "file_count": None, "elapsed_s": None,
+    }
+
+    def _write() -> None:
+        try:
+            SCAN_STATE_FILE.write_text(json.dumps(state), encoding="utf-8")
+        except OSError:
+            pass
+
+    def _job(remote: str, label: str = "") -> dict:
+        for item in state["remote_jobs"]:
+            if item.get("remote") == remote:
+                if label:
+                    item["label"] = label
+                return item
+        item = {
+            "remote": remote, "label": label, "status": "queued",
+            "files": 0, "skipped": 0, "total": None,
+        }
+        state["remote_jobs"].append(item)
+        return item
+
+    _write()
+    try:
+        proc = subprocess.Popen(
+            cmd,
+            stdout=subprocess.DEVNULL,  # scan mode outputs nothing useful to stdout
+            stderr=subprocess.PIPE,
+            text=True, encoding="utf-8", errors="replace",
+            creationflags=creationflags,
+        )
+        with _scan_lock:
+            _scan_proc = proc
+        for raw in proc.stderr:
+            line = raw.rstrip("\n")
+            if line.startswith("SCAN_START "):
+                try:
+                    d = json.loads(line[11:])
+                    state["remotes"] = d.get("remotes", [])
+                    state["total_remotes"] = d.get("total", 0)
+                    for remote in state["remotes"]:
+                        _job(remote)
+                    _write()
+                except (json.JSONDecodeError, KeyError):
+                    pass
+            elif line.startswith("SCAN_REMOTE_START "):
+                # Emitted immediately before the file-count probe starts.
+                try:
+                    d = json.loads(line[18:])
+                    state["current_remote"] = d.get("remote")
+                    state["current_label"] = d.get("label")
+                    state["current_index"] = d.get("index", 0)
+                    state["files_this_remote"] = 0
+                    state["files_remote_total"] = None  # unknown until SCAN_REMOTE_COUNTED
+                    job = _job(d.get("remote"), d.get("label"))
+                    job.update({
+                        "status": "running",
+                        "index": d.get("index", 0),
+                        "of": d.get("of", state.get("total_remotes", 0)),
+                        "files": 0,
+                        "skipped": 0,
+                        "total": None,
+                        "incremental": bool(d.get("incremental")),
+                        "started_at": datetime.now().isoformat(),
+                    })
+                    _write()
+                except (json.JSONDecodeError, KeyError):
+                    pass
+            elif line.startswith("SCAN_REMOTE_COUNTED "):
+                # Emitted after remote_file_count() returns — total is now known.
+                try:
+                    d = json.loads(line[20:])
+                    state["files_remote_total"] = d.get("total")
+                    _job(d.get("remote"))["total"] = d.get("total")
+                    _write()
+                except (json.JSONDecodeError, KeyError):
+                    pass
+            elif line.startswith("SCAN_FILE_PROGRESS "):
+                # Emitted every CANCEL_CHECK_INTERVAL files from inside walk_remote.
+                try:
+                    d = json.loads(line[19:])
+                    state["files_this_remote"] = d.get("files", 0)
+                    if d.get("total") is not None:
+                        state["files_remote_total"] = d["total"]
+                    job = _job(d.get("remote"), d.get("label"))
+                    job["files"] = d.get("files", 0)
+                    job["skipped"] = d.get("skipped", 0)
+                    if d.get("total") is not None:
+                        job["total"] = d["total"]
+                    _write()
+                except (json.JSONDecodeError, KeyError):
+                    pass
+            elif line.startswith("SCAN_PROGRESS "):
+                # Emitted after each remote completes — cumulative total.
+                try:
+                    d = json.loads(line[14:])
+                    state["current_remote"] = d.get("remote")
+                    state["current_label"] = d.get("label")
+                    state["files_this_remote"] = d.get("files", 0)
+                    state["files_total"] = d.get("files_total", 0)
+                    job = _job(d.get("remote"), d.get("label"))
+                    job.update({
+                        "status": "completed",
+                        "files": d.get("files", 0),
+                        "file_count": d.get("file_count"),
+                        "incremental": bool(d.get("incremental", job.get("incremental"))),
+                        "finished_at": datetime.now().isoformat(),
+                    })
+                    _write()
+                except (json.JSONDecodeError, KeyError):
+                    pass
+            elif line == "SCAN_CANCELLED":
+                state["cancelled"] = True
+                _write()
+            elif line.startswith("Scan complete:"):
+                m = re.search(r"(\d+)\s*files\s*in\s*([\d.]+)s", line)
+                if m:
+                    state["file_count"] = int(m.group(1))
+                    state["elapsed_s"] = float(m.group(2))
+                    _write()
+        proc.wait()
+        state["done"] = True
+        state["scanning"] = False
+        state["rc"] = proc.returncode
+        state["finished_at"] = datetime.now().isoformat()
+        if state.get("cancelled") or _scan_cancel_requested:
+            state["cancelled"] = True
+            state["scan_ok"] = True  # clean cancel — not an error
+        else:
+            state["scan_ok"] = proc.returncode == 0
+            if proc.returncode != 0:
+                state["error"] = f"rc-jav exited {proc.returncode}"
+        for job in state["remote_jobs"]:
+            if job.get("status") == "running":
+                job["status"] = "cancelled" if state.get("cancelled") else "failed" if not state.get("scan_ok") else "completed"
+                job["finished_at"] = state["finished_at"]
+            elif job.get("status") == "queued" and (state.get("cancelled") or not state.get("scan_ok")):
+                job["status"] = "cancelled" if state.get("cancelled") else "failed"
+                job["finished_at"] = state["finished_at"]
+        _write()
+        log_event("scan_complete", ok=state["scan_ok"], rc=proc.returncode,
+                  cancelled=state.get("cancelled", False),
+                  file_count=state.get("file_count"), elapsed_s=state.get("elapsed_s"))
+    except Exception as e:
+        state.update({
+            "done": True, "scanning": False, "scan_ok": False,
+            "error": str(e), "finished_at": datetime.now().isoformat(),
+        })
+        for job in state.get("remote_jobs", []):
+            if job.get("status") in ("queued", "running"):
+                job["status"] = "failed"
+                job["finished_at"] = state["finished_at"]
+        _write()
+        log(f"_scan_worker error: {e}")
+    finally:
+        with _scan_lock:
+            _scan_thread = None
+            _scan_proc = None
+            _scan_cancel_requested = False
+
+
+def handle_scan(payload: dict) -> dict:
+    """Start rc-jav.py --scan in a background thread and return immediately.
+    The caller should poll scan_progress until done=true.
+    scan_since: optional rclone duration string (e.g. '24h')."""
+    global _scan_thread, _scan_script_path, _scan_cancel_requested
+    with _scan_lock:
+        if _scan_thread is not None and _scan_thread.is_alive():
+            return {"ok": True, "scanning": True, "already_running": True}
+        _scan_cancel_requested = False
+
+    script = resolve_rcjav(payload.get("rcjav_path", ""))
+    scan_since = (payload.get("scan_since") or "").strip()
+    cmd = [sys.executable, str(script), "--scan", "--basic"]
+    cmd += part_pattern_args(payload)
+    scan_roots = [
+        str(root).strip() for root in (payload.get("scan_roots") or [])
+        if isinstance(root, str) and str(root).strip()
+    ]
+    for root in scan_roots:
+        cmd += ["--target", root]
+    if scan_since:
+        cmd += ["--scan-since", scan_since]
+    creationflags = 0x08000000 if os.name == "nt" else 0
+
+    _scan_script_path = script
+    t = threading.Thread(target=_scan_worker, args=(cmd, creationflags, scan_since, scan_roots), daemon=True, name="scan-worker")
+    with _scan_lock:
+        _scan_thread = t
+    t.start()
+    return {"ok": True, "scanning": True, "started": True, "scan_roots": scan_roots}
+
+
+def _deferred_kill(proc: subprocess.Popen, delay_s: float = 5.0) -> None:
+    """Wait up to delay_s for proc to exit via the cancel flag, then terminate.
+    Runs in a daemon thread so it never blocks the message loop."""
+    time.sleep(delay_s)
+    try:
+        if proc.poll() is None:
+            proc.terminate()
+    except Exception:
+        pass
+
+
+def handle_scan_cancel(payload: dict) -> dict:
+    """Write a cancel flag file that rc-jav.py's walk_remote checks every
+    CANCEL_CHECK_INTERVAL files. rc-jav exits cleanly when it sees the flag.
+    A deferred kill fires after 5 s if rc-jav has not exited on its own —
+    this avoids terminating it mid-write (which would corrupt cache.json or
+    prevent SCAN_CANCELLED from reaching the scan-state parser)."""
+    global _scan_cancel_requested
+    with _scan_lock:
+        running = _scan_thread is not None and _scan_thread.is_alive()
+        proc = _scan_proc
+    if not running:
+        return {"ok": True, "cancelled": False, "message": "no scan running"}
+    _scan_cancel_requested = True
+    # Resolve the rc-jav directory so we write the flag next to rc-jav.py
+    # (where rc-jav.py looks for it via Path(__file__).parent / "scan-cancel.flag").
+    script = _scan_script_path or resolve_rcjav(payload.get("rcjav_path", ""))
+    cancel_flag = script.parent / "scan-cancel.flag"
+    try:
+        cancel_flag.write_text("cancel", encoding="utf-8")
+        if proc is not None and proc.poll() is None:
+            t = threading.Thread(
+                target=_deferred_kill, args=(proc, 5.0),
+                daemon=True, name="cancel-kill",
+            )
+            t.start()
+        return {"ok": True, "cancelled": True}
+    except Exception as e:
+        return {"ok": False, "error": str(e)}
+
+
+def handle_scan_progress(payload: dict) -> dict:
+    """Return current scan progress from SCAN_STATE_FILE."""
+    with _scan_lock:
+        running = _scan_thread is not None and _scan_thread.is_alive()
+    if not SCAN_STATE_FILE.exists():
+        return {"ok": True, "scanning": running, "done": not running, "no_state": True}
+    try:
+        state = json.loads(SCAN_STATE_FILE.read_text(encoding="utf-8"))
+        # Thread may have just finished — ensure state is consistent.
+        if not running and state.get("scanning"):
+            state["scanning"] = False
+            state["done"] = True
+        state.pop("ok", None)
+        return {"ok": True, **state}
+    except Exception as e:
+        return {"ok": False, "error": str(e)}
+
+
+def handle_scan_clear(payload: dict) -> dict:
+    """Clear persisted scan job UI history without touching cache.json."""
+    with _scan_lock:
+        running = _scan_thread is not None and _scan_thread.is_alive()
+    if running:
+        return {"ok": False, "error": "scan is still running; cancel it before clearing job history"}
+    try:
+        if SCAN_STATE_FILE.exists():
+            SCAN_STATE_FILE.unlink()
+        return {"ok": True, "cleared": True}
+    except Exception as e:
+        return {"ok": False, "error": str(e)}
+
+
+def handle_delete_skipped(payload: dict) -> dict:
+    """Delete one or more skipped (non-JAV) files by full_path and patch cache."""
+    paths = payload.get("paths") or []
+    if not isinstance(paths, list) or not paths:
+        return {"ok": False, "error": "paths must be a non-empty array"}
+    base = {
+        "mode": payload.get("mode", "trash"),
+        "trash_dir": payload.get("trash_dir", ""),
+        "allowed_remotes": payload.get("allowed_remotes", []),
+        "rcjav_path": payload.get("rcjav_path", ""),
+    }
+    results = []
+    deleted_paths = []
+    for path in paths:
+        r = handle_delete({**base, "path": path})
+        results.append({"path": path, **r})
+        if r.get("ok"):
+            deleted_paths.append(path)
+    # Patch skipped list in cache.json too
+    if deleted_paths:
+        try:
+            script = resolve_rcjav(payload.get("rcjav_path"))
+            cache_path = script.parent / "cache.json"
+            if cache_path.exists():
+                cache = json.loads(cache_path.read_text(encoding="utf-8"))
+                modified = False
+                for remote_key, remote_data in cache.get("remotes", {}).items():
+                    sep = "" if remote_key.endswith("/") else "/"
+                    prefix = remote_key + sep
+                    before = remote_data.get("skipped", []) or []
+                    after = [
+                        p for p in before
+                        if f"{prefix}{p}" not in deleted_paths
+                    ]
+                    if len(after) != len(before):
+                        remote_data["skipped"] = after
+                        modified = True
+                if modified:
+                    tmp = cache_path.with_suffix(cache_path.suffix + ".tmp")
+                    tmp.write_text(json.dumps(cache, indent=2), encoding="utf-8")
+                    os.replace(tmp, cache_path)
+        except Exception as e:
+            log(f"handle_delete_skipped cache patch error: {e}")
+        _patch_cache_remove_paths(payload.get("rcjav_path"), deleted_paths)
+    ok_count = sum(1 for r in results if r.get("ok"))
+    return {
+        "ok": ok_count > 0,
+        "results": results,
+        "deleted_count": ok_count,
+        "failed_count": len(results) - ok_count,
+    }
+
+
+def handle_get_keep_ranking(payload: dict) -> dict:
+    """Return the current keep_ranking config from rc-jav's config.json."""
+    script = resolve_rcjav(payload.get("rcjav_path", ""))
+    cfg_path = script.parent / "config.json"
+    cfg = {}
+    if cfg_path.exists():
+        try:
+            cfg = json.loads(cfg_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            pass
+    ranking = cfg.get("keep_ranking") or {}
+    defaults = {
+        "priority_folders": ["ClearJAV"],
+        "size_tolerance_mib": 0,
+        "format_preference": ["mkv", "mp4", "wmv", "avi"],
+        "tiebreak_res_tag": True,
+        "tiebreak_longer_name": True,
+    }
+    merged = {**defaults, **ranking}
+    return {"ok": True, "keep_ranking": merged, "is_default": not bool(cfg.get("keep_ranking"))}
+
+
+def handle_save_keep_ranking(payload: dict) -> dict:
+    """Write keep_ranking config to rc-jav's config.json."""
+    script = resolve_rcjav(payload.get("rcjav_path", ""))
+    cfg_path = script.parent / "config.json"
+    ranking = payload.get("keep_ranking")
+    if not isinstance(ranking, dict):
+        return {"ok": False, "error": "keep_ranking must be an object"}
+    # Validate fields
+    tolerance = ranking.get("size_tolerance_mib")
+    if tolerance is not None:
+        try:
+            tolerance = float(tolerance)
+            if tolerance < 0:
+                return {"ok": False, "error": "size_tolerance_mib must be >= 0"}
+        except (TypeError, ValueError):
+            return {"ok": False, "error": "size_tolerance_mib must be a number"}
+    fmt = ranking.get("format_preference")
+    if fmt is not None and not isinstance(fmt, list):
+        return {"ok": False, "error": "format_preference must be an array"}
+    priority_folders = ranking.get("priority_folders")
+    if priority_folders is not None and not isinstance(priority_folders, list):
+        return {"ok": False, "error": "priority_folders must be an array"}
+    cfg = {}
+    if cfg_path.exists():
+        try:
+            cfg = json.loads(cfg_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            pass
+    cfg["keep_ranking"] = ranking
+    try:
+        tmp = cfg_path.with_suffix(cfg_path.suffix + ".tmp")
+        tmp.write_text(json.dumps(cfg, indent=2), encoding="utf-8")
+        os.replace(tmp, cfg_path)
+    except OSError as e:
+        return {"ok": False, "error": f"failed to write config: {e}"}
+    return {"ok": True, "keep_ranking": ranking}
+
+
+def handle_list_remotes(payload: dict) -> dict:
+    """Return all rclone remotes (from `rclone listremotes`) plus the
+    default_source / default_target paths from rc-jav's config.json so the
+    options page can offer autocomplete when building profiles."""
+    creationflags = 0x08000000 if os.name == "nt" else 0
+    try:
+        proc = subprocess.run(
+            [RCLONE_BIN, "listremotes"],
+            capture_output=True, text=True, timeout=15,
+            encoding="utf-8", errors="replace",
+            creationflags=creationflags,
+        )
+        remotes = [r.strip() for r in (proc.stdout or "").splitlines() if r.strip()]
+    except Exception as e:
+        remotes = []
+        log(f"list_remotes: rclone listremotes failed: {e}")
+
+    # Also read config.json so the user sees their configured defaults.
+    script = resolve_rcjav(payload.get("rcjav_path", ""))
+    cfg_path = script.parent / "config.json"
+    default_source: list[str] = []
+    default_target: list[str] = []
+    if cfg_path.exists():
+        try:
+            cfg = json.loads(cfg_path.read_text(encoding="utf-8"))
+            default_source = cfg.get("default_source") or []
+            default_target = cfg.get("default_target") or []
+        except Exception:
+            pass
+
+    return {
+        "ok": True,
+        "remotes": remotes,
+        "default_source": default_source,
+        "default_target": default_target,
+    }
+
+
+DISPATCH = {
+    "search": handle_search,
+    "bulk_search": handle_bulk_search,
+    "dupe_review": handle_dupe_review,
+    "delete_batch": handle_delete_batch,
+    "library_issues": handle_library_issues,
+    "rename_file": handle_rename_file,
+    "rename_files_batch": handle_rename_files_batch,
+    "ping": handle_ping,
+    "delete": handle_delete,
+    "diagnostics": handle_diagnostics,
+    "host_status": handle_host_status,
+    "host_repair": handle_host_repair,
+    "cache_status": handle_cache_status,
+    "recent_deletes": handle_recent_deletes,
+    "undo_delete": handle_undo_delete,
+    "scan": handle_scan,
+    "scan_progress": handle_scan_progress,
+    "scan_cancel": handle_scan_cancel,
+    "scan_clear": handle_scan_clear,
+    "list_remotes": handle_list_remotes,
+    "delete_skipped": handle_delete_skipped,
+    "get_keep_ranking": handle_get_keep_ranking,
+    "save_keep_ranking": handle_save_keep_ranking,
+}
+
+
+def main():
+    log(f"--- host start pid={os.getpid()} ---")
+    while True:
+        try:
+            msg = read_message()
+        except Exception as e:
+            log(f"read error: {e}\n{traceback.format_exc()}")
+            break
+        if msg is None:
+            log("stdin closed, exiting")
+            break
+        req_id = msg.get("req_id")
+        action = msg.get("action", "search")
+        handler = DISPATCH.get(action)
+        if not handler:
+            write_message({"req_id": req_id, "ok": False, "error": f"unknown action {action}"})
+            continue
+        t0 = time.monotonic()
+        try:
+            resp = handler(msg)
+        except Exception as e:
+            log(f"handler error: {e}\n{traceback.format_exc()}")
+            resp = {"ok": False, "error": str(e)}
+        elapsed_ms = round((time.monotonic() - t0) * 1000)
+        # Structured event log — include search-specific fields for analytics.
+        event_extra: dict = {"ok": resp.get("ok"), "elapsed_ms": elapsed_ms}
+        if action == "search":
+            event_extra["id"] = msg.get("id")
+            event_extra["hits"] = resp.get("hits")
+            event_extra["search_mode"] = resp.get("search_mode")
+        elif action in ("delete", "undo_delete", "scan"):
+            if not resp.get("ok"):
+                event_extra["error"] = (resp.get("error") or "")[:200]
+        # Don't log every scan_progress poll — it'd flood the events log.
+        if action not in ("scan_progress",):
+            log_event(action, **event_extra)
+        resp["req_id"] = req_id
+        try:
+            write_message(resp)
+        except Exception as e:
+            log(f"write error: {e}")
+            break
+
+
+if __name__ == "__main__":
+    main()
diff --git a/host/register-host.bat b/host/register-host.bat
new file mode 100644
index 0000000..dbc5f2a
--- /dev/null
+++ b/host/register-host.bat
@@ -0,0 +1,17 @@
+@echo off
+REM Double-click this to register the native messaging host with Brave.
+REM Prompts for the extension ID, then runs install-host.ps1.
+
+setlocal
+set /p EXT_ID="Paste the rclone-jav extension ID from brave://extensions: "
+
+if "%EXT_ID%"=="" (
+    echo No ID entered. Aborting.
+    pause
+    exit /b 1
+)
+
+powershell.exe -NoProfile -ExecutionPolicy Bypass -File "%~dp0install-host.ps1" -ExtensionId "%EXT_ID%"
+echo.
+echo Done. Press any key to close.
+pause >nul
diff --git a/icons/icon-128.png b/icons/icon-128.png
new file mode 100644
index 0000000..7ffbb26
Binary files /dev/null and b/icons/icon-128.png differ
diff --git a/icons/icon-32.png b/icons/icon-32.png
new file mode 100644
index 0000000..d6877f5
Binary files /dev/null and b/icons/icon-32.png differ
diff --git a/manifest.json b/manifest.json
new file mode 100644
index 0000000..3ddd06a
--- /dev/null
+++ b/manifest.json
@@ -0,0 +1,44 @@
+{
+  "manifest_version": 3,
+  "name": "rclone-jav",
+  "version": "0.1.0",
+  "description": "Check current page title against your rc-jav library via native messaging.",
+  "permissions": [
+    "nativeMessaging",
+    "storage",
+    "contextMenus",
+    "notifications",
+    "activeTab",
+    "scripting"
+  ],
+  "host_permissions": ["<all_urls>"],
+  "background": {
+    "service_worker": "background.js"
+  },
+  "action": {
+    "default_popup": "popup.html",
+    "default_title": "rclone-jav — check page",
+    "default_icon": {
+      "32": "icons/icon-32.png",
+      "128": "icons/icon-128.png"
+    }
+  },
+  "icons": {
+    "32": "icons/icon-32.png",
+    "128": "icons/icon-128.png"
+  },
+  "options_page": "options.html",
+  "content_scripts": [
+    {
+      "matches": ["<all_urls>"],
+      "js": ["content.js"],
+      "run_at": "document_idle"
+    }
+  ],
+  "commands": {
+    "check-current-page": {
+      "suggested_key": { "default": "Alt+J" },
+      "description": "rclone-jav: check current page title"
+    }
+  }
+}
diff --git a/options.css b/options.css
new file mode 100644
index 0000000..63cacb6
--- /dev/null
+++ b/options.css
@@ -0,0 +1,367 @@
+/* rclone-jav options page styles
+ * Extracted from options.html step 2 of the console consolidation refactor.
+ * See mockups/console-consolidation-claude.html for sequence + rationale.
+ * Per-pane split happens later (step 6) alongside per-pane JS extraction. */
+
+body { font-family: -apple-system, Segoe UI, sans-serif; background: #0f0f0f; color: #ddd; margin: 0; padding: 24px; }
+.shell {
+  max-width: 1040px; margin: 0 auto;
+  background: #1a1a1a; border: 1px solid #2a2a2a; border-radius: 8px; overflow: hidden;
+  box-shadow: 0 10px 40px rgba(0,0,0,.4);
+}
+.layout { display: grid; grid-template-columns: 220px 1fr; min-height: 620px; }
+
+/* sidebar */
+.side { background: #131313; border-right: 1px solid #222; padding: 14px 0; position: sticky; top: 0; align-self: start; height: 100vh; max-height: 720px; overflow-y: auto; }
+.side .brand { padding: 2px 22px 16px; border-bottom: 1px solid #202020; margin-bottom: 14px; }
+.side .brand strong { display:block; color:#f3f3f3; font-size:14px; letter-spacing:.2px; }
+.side .brand span { display:block; color:#666; font-size:11px; margin-top:3px; }
+.side .group { padding: 0 14px; margin-bottom: 16px; }
+.side .group:last-child { margin-bottom: 0; }
+.side .gtitle { font-size: 10px; color: #555; text-transform: uppercase; letter-spacing: 1.5px; margin-bottom: 6px; padding: 0 8px; }
+.side .item { padding: 8px 10px; font-size: 13px; color: #aaa; cursor: pointer; border-radius: 5px; user-select: none; display: flex; align-items: center; gap: 9px; }
+.side .item .icon { width: 16px; opacity: 0.72; text-align:center; font-size:12px; }
+.side .item:hover { background: #1f1f1f; color: #ddd; }
+.side .item.active { background: #2a2a2a; color: #fff; box-shadow: inset 2px 0 #6ec1ff; }
+.side .item.danger { color: #faa; }
+.side .item.danger:hover { background: #2a1a1a; }
+.side .item.danger.active { background: #3a1a1a; color: #ffbbbb; }
+
+/* main pane */
+.main { padding: 26px 32px; overflow-y: auto; }
+.pane-head { margin-bottom: 18px; padding-bottom: 14px; border-bottom: 1px solid #242424; }
+.main h1 { margin: 0 0 5px; font-size: 19px; letter-spacing:.2px; }
+.main .pdesc { color: #888; font-size: 12px; margin: 0; line-height: 1.5; max-width: 700px; }
+.pane { display: none; }
+.pane.active { display: block; }
+
+/* common form bits */
+label { display: flex; align-items: center; gap: 10px; padding: 7px 0; font-size: 13px; cursor: pointer; }
+label .sublabel { color: #777; font-size: 11px; display: block; margin-top: 2px; }
+input[type=text], textarea {
+  width: 100%; background: #0d0d0d; color: #ddd; border: 1px solid #2a2a2a;
+  padding: 8px 10px; box-sizing: border-box; border-radius: 4px;
+  font-family: Consolas, monospace; font-size: 12px;
+}
+textarea { min-height: 80px; resize: vertical; }
+input[type=text]:focus, textarea:focus { border-color: #ff6f3c; outline: none; }
+.fieldset { background: #161616; border: 1px solid #2a2a2a; border-radius: 5px; padding: 13px 15px; margin-bottom: 12px; }
+.fieldset .ftitle { font-size: 11px; color: #999; text-transform: uppercase; letter-spacing: 1px; margin-bottom: 8px; font-weight: 650; }
+.help { color: #777; font-size: 11px; margin: 4px 0 10px; line-height: 1.4; }
+.help code { background: #0d0d0d; padding: 2px 4px; border-radius: 3px; font-size: 11px; }
+select, input[type=number], input[type=color] { background:#0d0d0d; color:#ddd; border:1px solid #2a2a2a; border-radius:4px; font-family:Consolas,monospace; font-size:12px; }
+select { padding: 6px 8px; }
+input[type=number] { padding:6px 8px; }
+.setting-list { display:grid; gap: 2px; }
+.setting-list label { border-bottom: 1px solid #222; padding: 9px 0; }
+.setting-list label:last-child { border-bottom: 0; }
+.split-grid { display:grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 12px; }
+.button-row { display:flex; gap:8px; align-items:center; flex-wrap:wrap; }
+.section-note { background:#101820; border:1px solid #24303a; color:#9dccff; border-radius:5px; padding:9px 11px; font-size:12px; line-height:1.45; margin-bottom:12px; }
+.section-note.warn { background:#242410; border-color:#4a4420; color:#ffdd77; }
+.section-note.danger { background:#2a1414; border-color:#5a2525; color:#ffb3b3; }
+.mono-output { margin-top:10px; font-family:Consolas,monospace; font-size:11px; color:#aaa; line-height:1.5; overflow-wrap:anywhere; }
+.compact-grid { display:grid; grid-template-columns: minmax(0, 1fr) auto; gap:8px; align-items:center; }
+.chip-row { display:flex; gap:6px; align-items:center; flex-wrap:wrap; }
+.chip-btn { padding: 4px 9px; font-size:11px; border-radius: 10px; }
+.activity-filters { display:flex; gap:6px; align-items:center; flex-wrap:wrap; margin-top:9px; }
+.activity-filter { padding:4px 10px; border-radius:12px; font-size:11px; }
+.activity-filter.active { background:#1a2430; border-color:#36526a; color:#9dccff; }
+.activity-entry { margin-top:8px; }
+.activity-head { display:flex; align-items:center; gap:7px; flex-wrap:wrap; }
+.activity-pill { border:1px solid #333; border-radius:11px; padding:2px 8px; font-size:10px; font-weight:700; letter-spacing:.04em; text-transform:uppercase; white-space:nowrap; }
+.activity-pill.hit { background:#15351e; border-color:#285c38; color:#8ff0ae; }
+.activity-pill.miss { background:#383315; border-color:#655a24; color:#ffe487; }
+.activity-pill.no-id { background:#172839; border-color:#2d4f70; color:#9dccff; }
+.activity-pill.paused { background:#292334; border-color:#493b62; color:#d0b5ff; }
+.activity-pill.error { background:#3a1a1a; border-color:#722; color:#faa; }
+.activity-meta { color:#aaa; }
+/* Non-JAV files panel (skipped files in cache status) */
+.nonjav-panel { margin-top: 8px; background: rgba(255,255,255,.02); border: 1px solid #1e1e2a; border-radius: 6px; overflow: hidden; }
+.nonjav-panel-head { display: flex; align-items: center; gap: 8px; padding: 7px 12px; background: rgba(255,255,255,.03); border-bottom: 1px solid #1e1e2a; }
+.nonjav-panel-title { font-size: 12px; color: #b0b0c8; flex: 1; }
+.nonjav-del-all { font-size: 11px; padding: 3px 10px; border-radius: 10px; background: rgba(248,113,113,.12); border: 1px solid rgba(248,113,113,.25); color: #fca5a5; cursor: pointer; }
+.nonjav-del-all:hover { background: rgba(248,113,113,.22); }
+.nonjav-del-all:disabled { opacity: 0.4; cursor: default; }
+.nonjav-list { max-height: 220px; overflow-y: auto; scrollbar-width: thin; scrollbar-color: #2a2a3a #0d0d1a; }
+.nonjav-item { display: flex; align-items: center; gap: 8px; padding: 5px 12px; border-bottom: 1px solid rgba(255,255,255,.04); font-size: 11px; }
+.nonjav-item:last-child { border-bottom: none; }
+.nonjav-item.deleted { opacity: 0.35; pointer-events: none; }
+.nonjav-ext { font-family: Consolas, monospace; font-size: 10px; padding: 1px 5px; border-radius: 3px; background: rgba(255,255,255,.06); color: #888; flex-shrink: 0; min-width: 36px; text-align: center; }
+.nonjav-path { flex: 1; font-family: Consolas, monospace; color: #9090b0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.nonjav-del-one { font-size: 10px; padding: 2px 8px; border-radius: 8px; background: rgba(248,113,113,.08); border: 1px solid rgba(248,113,113,.2); color: #f87171; cursor: pointer; flex-shrink: 0; }
+.nonjav-del-one:hover { background: rgba(248,113,113,.18); }
+.nonjav-status { font-size: 11px; padding: 5px 12px; color: #8888aa; }
+.muted { color:#777; font-size:11px; }
+.disabled-soft { opacity:.48; }
+.danger-zone { border-color:#5a2525; background:#201414; }
+.scan-job-head { display:flex; gap:8px; align-items:center; flex-wrap:wrap; margin-bottom:8px; }
+.scan-pill { border-radius:10px; padding:2px 8px; background:#1a2430; color:#9dccff; border:1px solid #2d4258; font-size:10px; font-weight:700; text-transform:uppercase; }
+.scan-pill.ok { background:#1a3a1a; color:#afa; border-color:#2e5a2e; }
+.scan-pill.fail { background:#3a1a1a; color:#faa; border-color:#722; }
+.scan-remote { border-top:1px solid #242424; padding:7px 0; }
+.scan-remote:first-of-type { border-top:0; }
+.scan-track { height:4px; margin-top:5px; background:#202020; border-radius:3px; overflow:hidden; }
+.scan-fill { height:100%; background:#6ec1ff; min-width:0; }
+
+/* buttons */
+button { background: #2a2a2a; color: #ddd; border: 1px solid #3a3a3a; border-radius: 4px; padding: 6px 14px; font-size: 12px; cursor: pointer; font-family: inherit; }
+button:hover { background: #333; }
+button.primary { background: #1a3a1a; border-color: #2e5a2e; color: #afa; font-weight: 600; letter-spacing: 0.3px; }
+button.primary:hover { background: #235023; }
+button.danger { background: #511; border-color: #722; color: #faa; font-weight: 600; letter-spacing: 0.5px; }
+button.danger:hover { background: #722; }
+.actions { display: flex; gap: 8px; align-items: center; padding-top: 14px; border-top: 1px solid #222; margin-top: 20px; position: sticky; bottom: 0; background: linear-gradient(180deg, rgba(26,26,26,0), #1a1a1a 30%); }
+.actions .saved { color: #afa; font-size: 12px; margin-left: 8px; opacity: 0; transition: opacity .2s; }
+.actions .saved.show { opacity: 1; }
+
+/* adapter table */
+.adapters { width: 100%; border-collapse: collapse; }
+.adapters th, .adapters td { padding: 6px 6px; text-align: left; font-size: 12px; border-bottom: 1px solid #232323; vertical-align: middle; }
+.adapters th { color: #888; font-weight: normal; }
+.adapters th:nth-child(1), .adapters td:nth-child(1) { width: 200px; }
+.adapters th:nth-child(3), .adapters td:nth-child(3) { width: 32px; text-align: right; }
+.adapters td input { width: 100%; height: 28px; padding: 4px 6px; }
+.adapters button.del { background: #511; border: 1px solid #722; color: #faa; padding: 0; width: 26px; height: 26px; line-height: 24px; font-size: 14px; border-radius: 3px; }
+
+/* diagnostics rows */
+.diag-row { padding: 6px 10px; border-radius: 4px; margin-bottom: 4px; font-size: 12px; display: grid; grid-template-columns: 30px 150px 1fr; gap: 10px; align-items: start; }
+.diag-row.ok { background: #1a3a1a; color: #afa; }
+.diag-row.warn { background: #3a3a1a; color: #ffa; }
+.diag-row.fail { background: #3a1a1a; color: #faa; }
+.diag-row.info { background: #1a2430; color: #9dccff; }
+.diag-row .icon { font-weight: 700; }
+.diag-row .name { font-weight: 600; }
+.diag-row .detail { color: rgba(255,255,255,0.72); font-family: Consolas, monospace; font-size: 11px; overflow-wrap: anywhere; }
+.diag-row details { margin: 0; }
+.diag-row summary { cursor: pointer; color: rgba(255,255,255,0.85); }
+.diag-row pre { white-space: pre-wrap; margin: 6px 0 0; font-family: Consolas, monospace; font-size: 11px; color: rgba(255,255,255,0.72); }
+.diag-action { margin-top: 6px; display: flex; gap: 6px; flex-wrap: wrap; }
+.diag-action button { padding: 3px 8px; font-size: 11px; }
+
+/* radio chips */
+.radio-group { display: flex; gap: 6px; margin: 10px 0; }
+.radio-group label { background: #161616; border: 1px solid #2a2a2a; padding: 6px 12px; border-radius: 4px; font-size: 12px; padding-top: 6px; padding-bottom: 6px; }
+.radio-group label input { margin: 0 6px 0 0; }
+.radio-group label.selected { background: #1a3a1a; border-color: #2e5a2e; color: #afa; }
+.radio-group label.selected.danger { background: #3a1a1a; border-color: #722; color: #faa; }
+
+code { background: #0d0d0d; padding: 2px 5px; border-radius: 3px; font-size: 11px; font-family: Consolas, monospace; }
+
+/* Overlay horizontal tabs */
+.overlay-tabs { display: flex; gap: 0; margin-bottom: 16px; border-bottom: 1px solid #2a2a2a; }
+.otab { background: none; border: none; border-bottom: 2px solid transparent; color: #666; font-size: 13px; font-weight: 600; padding: 8px 18px; cursor: pointer; border-radius: 0; margin-bottom: -1px; letter-spacing: 0.3px; transition: color .15s, border-color .15s; }
+.otab:hover { color: #aaa; background: none; }
+.otab.active { color: #ddd; border-bottom-color: #6ec1ff; }
+.otab-panel { display: none; }
+.otab-panel.active { display: block; }
+.modal-backdrop { position: fixed; inset: 0; background: rgba(0,0,0,.72); z-index: 30; display: none; align-items: center; justify-content: center; padding: 24px; }
+.modal-backdrop.open { display: flex; }
+.modal { width: min(860px, 100%); max-height: min(760px, calc(100vh - 48px)); background:#161616; border:1px solid #343434; border-radius:8px; box-shadow:0 18px 80px rgba(0,0,0,.6); display:flex; flex-direction:column; overflow:hidden; }
+.modal-head, .modal-actions { display:flex; gap:10px; align-items:center; justify-content:space-between; padding:14px 16px; border-bottom:1px solid #262626; }
+.modal-actions { border-bottom:0; border-top:1px solid #262626; justify-content:flex-end; }
+.modal-title { font-size:15px; font-weight:650; color:#f1f1f1; }
+.modal-subtitle { margin-top:3px; color:#777; font-size:11px; font-family:Consolas,monospace; overflow-wrap:anywhere; }
+.modal-body { padding:14px 16px; overflow:auto; }
+.modal-help { color:#888; font-size:12px; line-height:1.45; margin-bottom:12px; }
+.modal-field { margin-bottom:12px; }
+.modal-field > label { display:block; color:#bbb; font-size:12px; padding:0; margin-bottom:5px; cursor:default; }
+.modal-field .prof-remote-group { background:#0a0a0a; border:1px solid #222; border-radius:4px; padding:8px 10px; }
+.profile-card { background:#161616; border:1px solid #2a2a2a; border-radius:5px; padding:12px 14px; margin-bottom:10px; display:grid; grid-template-columns:minmax(0,1fr) auto; gap:12px; align-items:start; }
+.profile-card .name { color:#f1f1f1; font-weight:650; margin-bottom:5px; }
+.profile-card .roots { color:#888; font-family:Consolas,monospace; font-size:11px; line-height:1.5; overflow-wrap:anywhere; }
+.profile-card .actions { margin:0; display:flex; gap:6px; align-items:center; }
+.profile-card .actions button { padding:4px 9px; font-size:11px; }
+.modal-confirm { background:#201414; border:1px solid #5a2525; border-radius:5px; color:#ffb3b3; font-size:12px; line-height:1.5; padding:11px 12px; }
+.part-detector-list { display:grid; gap:9px; }
+.part-detector-row { background:#101010; border:1px solid #252525; border-radius:5px; padding:10px; }
+.part-detector-row.builtin { background:#101820; border-color:#24303a; }
+.part-detector-head { display:grid; grid-template-columns:minmax(0,1fr) 28px; gap:8px; align-items:center; }
+.part-detector-row.builtin .part-detector-head { grid-template-columns:minmax(0,1fr) auto; }
+.part-detector-head input { min-width:0; }
+.part-detector-head input:read-only { color:#9dccff; }
+.part-detector-head button { background:#511; border-color:#722; color:#faa; width:28px; height:28px; padding:0; font-size:14px; }
+.part-detector-kind { color:#9dccff; border:1px solid #314453; border-radius:10px; padding:2px 8px; font-size:10px; font-weight:650; white-space:nowrap; }
+.part-detector-feedback { margin-top:7px; font-size:11px; line-height:1.45; color:#888; }
+.part-detector-feedback .ok { color:#afa; }
+.part-detector-feedback .warn { color:#ffdd77; }
+.part-detector-feedback .fail { color:#faa; }
+.part-detector-match { color:#9dccff; font-family:Consolas,monospace; margin-top:3px; overflow-wrap:anywhere; }
+.skip-summary { display:flex; gap:6px; flex-wrap:wrap; margin-bottom:12px; }
+.skip-summary span { background:#242410; border:1px solid #4a4420; color:#ffdd77; border-radius:10px; padding:3px 8px; font-size:11px; }
+.skip-row { border-top:1px solid #242424; padding:9px 0; }
+.skip-row:first-of-type { border-top:0; }
+.skip-row .name { color:#ddd; font-family:Consolas,monospace; font-size:12px; }
+.skip-row .reason { color:#ffdd77; font-size:11px; margin-top:3px; }
+.skip-row .path { color:#777; font-family:Consolas,monospace; font-size:11px; margin-top:3px; overflow-wrap:anywhere; }
+.cache-freshness { display:flex; gap:14px; align-items:center; flex-wrap:wrap; margin:8px 0 10px; }
+.cache-freshness label { display:inline-flex; gap:8px; align-items:center; padding:0; white-space:nowrap; cursor:default; }
+.cache-freshness input { width:66px; }
+.cache-freshness .sublabel { max-width:340px; margin:0; line-height:1.35; }
+
+/* ── Duplicate Review — Variant 9 (Frosted Modern) ─────────────────── */
+#dupe-review-modal .modal { background: linear-gradient(135deg, #0f0f1a 0%, #0d1117 100%); border-color: #2a2a3a; width: 65vw; }
+#dupe-review-modal .modal-head { background: linear-gradient(90deg, #12122a, #0d0d1a); border-bottom-color: #1e1e3a; }
+#dupe-review-modal .modal-title { color: #e8e8ff; }
+#dupe-review-modal .modal-subtitle { color: #8888aa; font-family: system-ui, sans-serif; }
+#dupe-review-modal .modal-head button { color: #6060aa; border-color: #2a2a4a; }
+#dupe-review-modal .modal-head button:hover { color: #b0b0d0; background: rgba(255,255,255,.05); }
+#dupe-review-modal .modal-actions { border-top-color: #1a1a2a; background: rgba(0,0,0,.3); }
+#dupe-review-modal .modal-actions button { background: rgba(255,255,255,.07); border-color: #3a3a5a; color: #c8c8e8; }
+#dupe-review-modal .modal-actions button:hover { background: rgba(255,255,255,.13); }
+#dupe-review-modal .modal-body { padding: 0; scrollbar-width: thin; scrollbar-color: #2a2a4a #0d0d1a; }
+#dupe-review-modal .modal-body::-webkit-scrollbar { width: 6px; }
+#dupe-review-modal .modal-body::-webkit-scrollbar-track { background: #0d0d1a; }
+#dupe-review-modal .modal-body::-webkit-scrollbar-thumb { background: #2a2a4a; border-radius: 3px; }
+#dupe-review-modal .modal-body::-webkit-scrollbar-thumb:hover { background: #3a3a6a; }
+
+.dr-stats { display: flex; border-bottom: 1px solid #1e1e32; }
+.dr-stat { flex: 1; padding: 11px 16px; border-right: 1px solid #1e1e32; }
+.dr-stat:last-child { border-right: none; }
+.dr-stat .val { font-size: 17px; font-weight: 700; color: #fff; }
+.dr-stat .val.red { color: #f87171; }
+.dr-stat .val.blue { color: #60a5fa; }
+.dr-stat .key { font-size: 10px; color: #aaaacc; margin-top: 2px; text-transform: uppercase; letter-spacing: .07em; }
+
+.dr-roots { font-size: 12px; color: #9999bb; padding: 6px 16px; border-bottom: 1px solid #1a1a2a; font-family: Consolas, monospace; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+
+.dr-body { padding: 12px; display: flex; flex-direction: column; gap: 8px; }
+
+.dr-card-wrap { display: flex; align-items: stretch; }
+.dr-card-wrap.dr-hidden { display: none; }
+.dr-card-wrap.skipped .dr-card { opacity: 0.38; pointer-events: none; }
+.dr-card-wrap.skipped .dr-skip-ear { background: rgba(251,191,36,.07); border-color: rgba(251,191,36,.25); }
+.dr-card-wrap.skipped .dr-skip-ear span { color: #fbbf24; }
+.dr-card-wrap.dr-risk .dr-card { border-color: rgba(251,191,36,.28); }
+.dr-skip-ear { width: 24px; flex-shrink: 0; display: flex; align-items: center; justify-content: center; cursor: pointer; background: rgba(255,255,255,.02); border: 1px solid rgba(255,255,255,.06); border-left: none; border-radius: 0 6px 6px 0; transition: background .15s; }
+.dr-skip-ear:hover { background: rgba(255,255,255,.07); }
+.dr-skip-ear span { font-size: 8px; color: #333; writing-mode: vertical-rl; letter-spacing: 1px; text-transform: uppercase; font-weight: 700; user-select: none; transition: color .15s; }
+.dr-skip-ear:hover span { color: #777; }
+.dr-card { background: rgba(255,255,255,.03); border: 1px solid rgba(255,255,255,.06); border-radius: 8px 0 0 8px; overflow: hidden; flex: 1; min-width: 0; }
+.dr-card-head { display: flex; align-items: center; padding: 9px 14px; gap: 8px; border-bottom: 1px solid rgba(255,255,255,.04); }
+.dr-card-id { font-weight: 700; color: #e0e0ff; font-family: Consolas, monospace; font-size: 13px; }
+.dr-card-reclaim { margin-left: auto; font-size: 11px; color: #ff7171; background: rgba(255,100,100,.1); padding: 2px 9px; border-radius: 12px; white-space: nowrap; }
+.dr-card-body { padding: 9px 14px; display: flex; flex-direction: column; gap: 7px; }
+
+.dr-badge { font-size: 9px; font-weight: 700; letter-spacing: .07em; padding: 2px 7px; border-radius: 10px; white-space: nowrap; }
+.dr-badge.b4k      { background: rgba(96,165,250,.12);  color: #60a5fa;  border: 1px solid rgba(96,165,250,.2); }
+.dr-badge.b1080    { background: rgba(167,139,250,.12); color: #a78bfa;  border: 1px solid rgba(167,139,250,.2); }
+.dr-badge.bcljav   { background: rgba(74,222,128,.12);  color: #4ade80;  border: 1px solid rgba(74,222,128,.2); }
+.dr-badge.bfmt     { background: rgba(251,146,60,.12);  color: #fb923c;  border: 1px solid rgba(251,146,60,.2); }
+.dr-badge.bmkv     { background: rgba(251,146,60,.09);  color: #fb923c;  border: 1px solid rgba(251,146,60,.15); }
+
+.dr-row { display: flex; align-items: center; gap: 10px; min-width: 0; }
+.dr-tag { font-size: 9px; font-weight: 700; letter-spacing: .08em; padding: 2px 8px; border-radius: 10px; min-width: 58px; text-align: center; white-space: nowrap; flex-shrink: 0; }
+.dr-tag.keep { background: rgba(74,222,128,.12); color: #4ade80; border: 1px solid rgba(74,222,128,.2); }
+.dr-tag.del  { background: rgba(248,113,113,.12); color: #f87171; border: 1px solid rgba(248,113,113,.2); }
+.dr-tag.cat  { background: rgba(96,165,250,.12);  color: #93c5fd; border: 1px solid rgba(96,165,250,.2); }
+.dr-path { font-family: Consolas, monospace; font-size: 11px; color: #9090b0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; flex: 1; min-width: 0; }
+.dr-row.keep .dr-path { color: #c0c0e0; }
+.dr-keep-reason { color:#8ff0ae; font-size:10px; font-family:Consolas,monospace; margin:-2px 0 2px 68px; }
+.dr-risk-note { background:rgba(251,191,36,.09); border:1px solid rgba(251,191,36,.24); border-radius:5px; color:#ffe487; font-size:11px; line-height:1.42; margin:0 0 3px; padding:7px 9px; }
+.dr-risk-note strong { color:#fff0b0; }
+.dr-sz { font-size: 11px; font-weight: 600; white-space: nowrap; flex-shrink: 0; }
+.dr-sz.keep { color: #4ade80; }
+.dr-sz.del  { color: #f87171; }
+.dr-sz.cat  { color: #93c5fd; }
+
+/* Interactive delete row states */
+.dr-row.del { cursor: default; }
+.dr-row.del:hover { background: rgba(248,113,113,.03); }
+.dr-row.del.confirmed { background: rgba(248,113,113,.08); }
+.dr-row.del.confirmed .dr-tag.del { background: rgba(248,113,113,.25); color: #fca5a5; border-color: rgba(248,113,113,.4); }
+.dr-row.del.confirmed .dr-path { text-decoration: line-through; text-decoration-color: #f87171; }
+.dr-row.del.done { opacity: 0.35; pointer-events: none; }
+.dr-row.del.done .dr-path { text-decoration: line-through; color: #555; }
+.dr-row.del.error .dr-tag.del { background: rgba(251,191,36,.12); color: #fbbf24; border-color: rgba(251,191,36,.25); }
+/* KEEP row — clickable to swap roles */
+.dr-row.keep { cursor: pointer; user-select: none; }
+.dr-row.keep:hover { background: rgba(248,113,113,.03); }
+
+#dupe-review-execute { background: rgba(248,113,113,.15); border-color: rgba(248,113,113,.3); color: #fca5a5; }
+#dupe-review-execute:hover:not(:disabled) { background: rgba(248,113,113,.25); }
+#dupe-review-execute:disabled { opacity: 0.4; cursor: default; }
+
+.dr-empty { padding: 20px 16px; color: #3a3a6a; font-size: 13px; }
+.dr-skipped { padding: 8px 16px 12px; font-size: 11px; color: #bbbbdd; }
+.dr-skipped-item { font-family: Consolas, monospace; font-size: 10px; color: #9999bb; margin-top: 3px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+
+/* Keep Ranking Panel */
+.kr-panel { background: rgba(96,165,250,.04); border: 1px solid rgba(96,165,250,.12); border-radius: 8px; padding: 14px 16px; margin-top: 10px; }
+.kr-info { font-size: 11px; color: #8888aa; margin-bottom: 12px; line-height: 1.5; }
+.kr-info code { background: rgba(255,255,255,.07); padding: 1px 5px; border-radius: 3px; font-family: Consolas, monospace; color: #93c5fd; }
+.kr-row { display: flex; align-items: center; gap: 10px; margin-bottom: 10px; }
+.kr-label { font-size: 12px; color: #b0b0c8; width: 140px; flex-shrink: 0; }
+.kr-input { width: 70px; background: rgba(255,255,255,.06); border: 1px solid #2a2a3a; border-radius: 5px; color: #c0c0e0; font-size: 12px; padding: 4px 8px; }
+.kr-input:focus { outline: none; border-color: rgba(96,165,250,.4); }
+.kr-unit { font-size: 11px; color: #666; }
+.kr-toggle { display: flex; align-items: center; gap: 6px; font-size: 12px; color: #b0b0c8; cursor: pointer; }
+.kr-toggle input[type=checkbox] { accent-color: #60a5fa; }
+.kr-fmt-list { display: flex; flex-direction: column; gap: 4px; min-width: 130px; }
+.kr-fmt-item { display: flex; align-items: center; gap: 6px; background: rgba(255,255,255,.04); border: 1px solid #2a2a3a; border-radius: 5px; padding: 5px 8px; cursor: grab; font-size: 12px; color: #c0c0e0; font-family: Consolas, monospace; user-select: none; }
+.kr-fmt-item.dragging { opacity: 0.4; }
+.kr-fmt-item.drag-over { border-color: rgba(96,165,250,.5); background: rgba(96,165,250,.08); }
+.kr-fmt-grip { color: #444; font-size: 10px; cursor: grab; }
+.kr-fmt-priority { font-size: 10px; color: #555; margin-left: auto; }
+.kr-save-row { display: flex; align-items: center; gap: 10px; margin-top: 14px; }
+.kr-save-status { font-size: 11px; color: #8888aa; flex: 1; }
+.kr-save-status.ok { color: #6ee7b7; }
+.kr-save-status.err { color: #f87171; }
+
+/* Library Issues modal */
+#library-issues-modal .modal { background: linear-gradient(135deg, #0f0f1a 0%, #0d1117 100%); border-color: #2a2a3a; width: 65vw; }
+#library-issues-modal .modal-head { background: linear-gradient(90deg, #12122a, #0d0d1a); border-bottom-color: #1e1e3a; }
+#library-issues-modal .modal-title { color: #e8e8ff; }
+#library-issues-modal .modal-subtitle { color: #8888aa; font-family: system-ui, sans-serif; }
+#library-issues-modal .modal-head button { color: #6060aa; border-color: #2a2a4a; }
+#library-issues-modal .modal-head button:hover { color: #b0b0d0; background: rgba(255,255,255,.05); }
+#library-issues-modal .modal-actions { border-top-color: #1a1a2a; background: rgba(0,0,0,.3); }
+#library-issues-modal .modal-actions button { background: rgba(255,255,255,.07); border-color: #3a3a5a; color: #c8c8e8; }
+#library-issues-modal .modal-actions button:hover { background: rgba(255,255,255,.13); }
+#library-issues-modal .modal-body { padding: 0; scrollbar-width: thin; scrollbar-color: #2a2a4a #0d0d1a; }
+#library-issues-modal .modal-body::-webkit-scrollbar { width: 6px; }
+#library-issues-modal .modal-body::-webkit-scrollbar-track { background: #0d0d1a; }
+#library-issues-modal .modal-body::-webkit-scrollbar-thumb { background: #2a2a4a; border-radius: 3px; }
+
+/* Library issue rows */
+.li-section-head { padding: 8px 16px; font-size: 11px; font-weight: 600; color: #fbbf24; background: rgba(251,191,36,.06); border-bottom: 1px solid rgba(251,191,36,.12); }
+.li-row { display: grid; grid-template-columns: auto 1fr auto auto; gap: 8px; align-items: center; padding: 7px 16px; border-bottom: 1px solid rgba(255,255,255,.04); }
+.li-row:hover { background: rgba(255,255,255,.03); }
+.li-tag { font-size: 10px; font-weight: 600; padding: 2px 7px; border-radius: 10px; white-space: nowrap; }
+.li-tag.bracket { background: rgba(251,191,36,.12); color: #fbbf24; border: 1px solid rgba(251,191,36,.25); }
+.li-tag.nohyphen { background: rgba(167,139,250,.12); color: #c4b5fd; border: 1px solid rgba(167,139,250,.25); }
+.li-tag.done { background: rgba(74,222,128,.12); color: #4ade80; border: 1px solid rgba(74,222,128,.25); }
+.li-tag.conflict { background: rgba(248,113,113,.12); color: #f87171; border: 1px solid rgba(248,113,113,.25); }
+.li-names { display: flex; flex-direction: column; gap: 2px; min-width: 0; }
+.li-old { font-family: Consolas, monospace; font-size: 11px; color: #8888aa; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.li-arrow { font-size: 11px; color: #4ade80; }
+.li-new { font-family: Consolas, monospace; font-size: 11px; color: #c0c0e0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.li-sz { font-size: 11px; color: #6060aa; white-space: nowrap; }
+.li-rename-btn { font-size: 11px; padding: 3px 10px; border-radius: 5px; border: 1px solid #3a3a5a; background: rgba(255,255,255,.06); color: #c8c8e8; cursor: pointer; white-space: nowrap; }
+.li-rename-btn:hover:not(:disabled) { background: rgba(255,255,255,.12); }
+.li-rename-btn:disabled { opacity: 0.4; cursor: default; }
+.li-empty { padding: 24px 16px; color: #4ade80; font-size: 13px; }
+.li-stats { padding: 10px 16px; font-size: 12px; color: #8888aa; border-bottom: 1px solid rgba(255,255,255,.06); }
+.li-stats b { color: #c8c8e8; }
+
+/* Dupe Review filter bar */
+.dr-filter-bar { position: sticky; top: 0; z-index: 5; display: flex; flex-wrap: wrap; align-items: center; gap: 5px; padding: 9px 14px; background: #0d0d1a; border-bottom: 1px solid #1e1e2a; }
+.dr-filter-label { font-size: 11px; color: #555; padding: 0 2px; white-space: nowrap; }
+.dr-filter-sep { width: 1px; height: 16px; background: #2a2a3a; margin: 0 4px; flex-shrink: 0; }
+.dr-chip { font-size: 11px; padding: 3px 11px; border-radius: 20px; border: 1px solid #2a2a3a; background: rgba(255,255,255,.04); color: #888; cursor: pointer; transition: all .15s; font-family: system-ui, sans-serif; }
+.dr-chip:hover { border-color: #3a3a5a; color: #aaa; }
+.dr-search { font-size: 11px; padding: 3px 10px; border-radius: 20px; border: 1px solid #2a2a3a; background: rgba(255,255,255,.04); color: #c0c0e0; outline: none; width: 160px; font-family: Consolas, monospace; }
+.dr-search::placeholder { color: #444; }
+.dr-search:focus { border-color: rgba(96,165,250,.4); background: rgba(96,165,250,.05); }
+.dr-chip.active { border-color: rgba(96,165,250,.4); background: rgba(96,165,250,.12); color: #93c5fd; }
+.dr-card.dr-hidden { display: none; }
+
+/* Variant alerts */
+.dr-variant-section { margin: 16px 0 0; }
+.dr-variant-heading { padding: 8px 16px; font-size: 12px; font-weight: 600; color: #fbbf24; background: rgba(251,191,36,.06); border-top: 1px solid rgba(251,191,36,.2); border-bottom: 1px solid rgba(251,191,36,.12); }
+.dr-card.variant-alert { border-color: rgba(251,191,36,.25); }
+.dr-card.variant-alert .dr-card-head { background: rgba(251,191,36,.06); }
+.dr-variant-label { font-size: 10px; font-weight: 500; color: #fbbf24; background: rgba(251,191,36,.12); border: 1px solid rgba(251,191,36,.25); padding: 1px 7px; border-radius: 10px; }
+.dr-tag.variant { background: rgba(251,191,36,.12); color: #fbbf24; border: 1px solid rgba(251,191,36,.25); }
+.dr-tag.bare { background: rgba(167,139,250,.12); color: #c4b5fd; border: 1px solid rgba(167,139,250,.25); }
+.dr-row.variant .dr-path { color: #c0c0e0; }
diff --git a/options.html b/options.html
new file mode 100644
index 0000000..c317cb7
--- /dev/null
+++ b/options.html
@@ -0,0 +1,806 @@
+<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>rclone-jav options</title>
+  <link rel="stylesheet" href="options.css">
+</head>
+<body>
+<div class="shell">
+<div class="layout">
+
+  <!-- ============================== SIDEBAR ============================== -->
+  <div class="side">
+    <div class="brand">
+      <strong>rclone-jav</strong>
+      <span>Extension settings</span>
+    </div>
+    <div class="group">
+      <div class="gtitle">Scanning</div>
+      <div class="item active" data-pane="triggers"><span class="icon">▶</span>Scan Behavior</div>
+      <div class="item" data-pane="overlays"><span class="icon">▣</span>Overlays</div>
+    </div>
+    <div class="group">
+      <div class="gtitle">Library</div>
+      <div class="item" data-pane="profiles"><span class="icon">☰</span>Profiles</div>
+      <div class="item" data-pane="search"><span class="icon">⌕</span>Cache &amp; Scans</div>
+      <div class="item" data-pane="maintenance"><span class="icon">≡</span>Library Review</div>
+    </div>
+    <div class="group">
+      <div class="gtitle">Matching</div>
+      <div class="item" data-pane="adapters"><span class="icon">⌖</span>Site Extraction</div>
+      <div class="item" data-pane="normalizers"><span class="icon">⇄</span>ID Rules</div>
+    </div>
+    <div class="group">
+      <div class="gtitle">System</div>
+      <div class="item" data-pane="paths"><span class="icon">⌘</span>Setup</div>
+      <div class="item" data-pane="diagnostics"><span class="icon">✓</span>Diagnostics</div>
+      <div class="item" data-pane="debug"><span class="icon">⚙</span>Debug Tools</div>
+    </div>
+    <div class="group">
+      <div class="gtitle">Danger</div>
+      <div class="item danger" data-pane="deletion"><span class="icon">×</span>Deletion</div>
+    </div>
+  </div>
+
+  <!-- ============================== MAIN ============================== -->
+  <div class="main">
+
+    <!-- TRIGGERS -->
+    <div class="pane active" id="pane-triggers">
+      <div class="pane-head">
+        <h1>Scan Behavior</h1>
+        <div class="pdesc">Choose when rclone-jav checks the current page.</div>
+      </div>
+      <div id="trigger-summary" class="section-note"></div>
+
+      <div class="fieldset">
+        <div class="ftitle">Scope</div>
+        <div class="setting-list">
+          <label><input type="checkbox" id="autoEveryPage"> Auto-check every page load
+            <span class="sublabel">Runs on every site. Badge shows "?" when no JAV ID detected.</span></label>
+
+          <label><input type="checkbox" id="autoKnownSites"> Auto-check on known JAV sites
+            <span class="sublabel">Only fires on host patterns listed below.</span></label>
+        </div>
+      </div>
+
+      <div class="fieldset">
+        <div class="ftitle">Known site patterns</div>
+        <div class="help">Comma- or newline-separated. Bare domain matches site + any subdomain (<code>clearjav.com</code> covers <code>www.clearjav.com</code>).</div>
+        <textarea id="knownSitePatterns" placeholder="clearjav.com&#10;javdb.com" style="resize:none;overflow:hidden;field-sizing:content;min-height:60px;"></textarea>
+        <div class="chip-row" style="margin-top:8px;">
+          <button id="add-current-site" class="chip-btn" type="button">Add Current Site</button>
+          <button id="add-clearjav-site" class="chip-btn" type="button">Add ClearJAV</button>
+          <span id="known-site-status" class="muted"></span>
+        </div>
+      </div>
+
+      <div class="fieldset">
+        <div class="ftitle">Navigation types</div>
+        <div class="setting-list">
+          <label><input type="checkbox" id="autoPageLoad"> Full page loads
+            <span class="sublabel">Runs when the browser reports the page has finished loading.</span></label>
+          <label><input type="checkbox" id="autoSpaNavigation"> SPA and history URL changes
+            <span class="sublabel">Runs when a site changes URL without a full reload, including browser back/forward on some sites.</span></label>
+        </div>
+      </div>
+
+      <div class="fieldset">
+        <div class="ftitle">Manual controls</div>
+        <div class="setting-list">
+          <label><input type="checkbox" id="toolbarClick"> Toolbar icon popup
+            <span class="sublabel">Click the rclone-jav icon to run a check on the active tab.</span></label>
+          <label><input type="checkbox" id="contextMenu"> Right-click context menu</label>
+          <label><input type="checkbox" id="keyboardShortcut"> Keyboard shortcut (Alt+J)
+            <span class="sublabel">Rebind at <code>brave://extensions/shortcuts</code>.</span></label>
+        </div>
+      </div>
+      <div class="actions">
+        <button class="primary save-btn">SAVE</button>
+        <span class="saved">Saved.</span>
+      </div>
+    </div>
+
+    <!-- OVERLAYS -->
+    <div class="pane" id="pane-overlays">
+      <div class="pane-head">
+        <h1>Overlays</h1>
+        <div class="pdesc">In-page toast notifications after auto-trigger scans.</div>
+      </div>
+      <div id="overlay-summary" class="section-note"></div>
+
+      <!-- Horizontal tabs -->
+      <div class="overlay-tabs">
+        <button class="otab active" data-otab="match">✓ Match</button>
+        <button class="otab" data-otab="nomatch">✗ No Match</button>
+      </div>
+
+      <!-- MATCH tab -->
+      <div class="otab-panel active" id="otab-match">
+        <label style="margin-bottom:10px;display:flex;align-items:center;gap:10px;">
+          <input type="checkbox" id="showOverlay"> Show overlay on match
+          <span class="sublabel" style="margin:0;">Hover to pause countdown. Auto-check only.</span>
+        </label>
+
+        <div class="fieldset">
+          <div style="display:flex;gap:14px;align-items:center;flex-wrap:wrap;">
+            <div>
+              <div style="font-size:11px;color:#888;margin-bottom:4px;">Position</div>
+              <div class="radio-group" style="margin:0;">
+                <label><input type="radio" name="overlayPosition" value="top-left"> Top-Left</label>
+                <label><input type="radio" name="overlayPosition" value="top-right" checked> Top-Right</label>
+                <label><input type="radio" name="overlayPosition" value="bottom-left"> Bottom-Left</label>
+                <label><input type="radio" name="overlayPosition" value="bottom-right"> Bottom-Right</label>
+              </div>
+            </div>
+            <div>
+              <div style="font-size:11px;color:#888;margin-bottom:4px;">Duration (sec)</div>
+              <input type="number" id="overlayDuration" value="5" min="1" max="60" step="1" style="width:80px;">
+            </div>
+          </div>
+          <label style="margin-top:10px;display:flex;align-items:center;gap:10px;">
+            <input type="checkbox" id="overlayGlow"> Subtle glow
+            <input type="color" id="overlayGlowColor" value="#6ec1ff" style="width:36px;height:24px;padding:0;cursor:pointer;" title="Glow color">
+          </label>
+          <div id="glow-detail" style="margin-top:10px;padding:10px;background:#101010;border:1px solid #232323;border-radius:4px;display:grid;grid-template-columns:90px 1fr 50px;gap:8px;align-items:center;font-size:11px;">
+            <span style="color:#888;">Blur (soft)</span>
+            <input type="range" id="overlayGlowBlur" min="0" max="60" step="1" value="10" style="width:100%;">
+            <span id="overlayGlowBlurVal" style="color:#6ec1ff;text-align:right;font-family:Consolas,monospace;">10 px</span>
+            <span style="color:#888;">Spread (size)</span>
+            <input type="range" id="overlayGlowSpread" min="0" max="40" step="1" value="0" style="width:100%;">
+            <span id="overlayGlowSpreadVal" style="color:#6ec1ff;text-align:right;font-family:Consolas,monospace;">0 px</span>
+            <span style="color:#888;">Opacity</span>
+            <input type="range" id="overlayGlowOpacity" min="0.05" max="1" step="0.05" value="0.35" style="width:100%;">
+            <span id="overlayGlowOpacityVal" style="color:#6ec1ff;text-align:right;font-family:Consolas,monospace;">0.35</span>
+          </div>
+          <div style="margin-top:8px;display:flex;justify-content:flex-end;">
+            <button id="overlay-reset" type="button" style="font-size:11px;padding:4px 10px;">Reset</button>
+          </div>
+        </div>
+
+        <div style="margin-top:12px;border-top:1px solid #222;padding-top:12px;">
+          <div style="font-size:11px;color:#888;margin-bottom:8px;display:flex;justify-content:space-between;align-items:center;">
+            <span>Preview <span id="overlay-preview-pos" style="color:#6ec1ff;">— top-right</span></span>
+            <button id="overlay-preview-replay" type="button" style="font-size:11px;padding:2px 8px;">Replay</button>
+          </div>
+          <div id="overlay-preview-stage" style="background:#080808;border:1px dashed #2a2a2a;border-radius:4px;padding:18px;display:flex;justify-content:flex-end;align-items:flex-start;min-height:130px;position:relative;">
+            <div id="overlay-preview" style="width:280px;background:#1a1a1a;color:#ddd;border:1px solid #2a2a2a;border-radius:6px;font-size:12px;overflow:hidden;box-shadow:0 6px 20px rgba(0,0,0,.55);">
+              <div style="padding:6px 10px;background:#1e3a1e;color:#afa;font-weight:600;display:flex;align-items:center;gap:6px;font-size:12px;"><span>✓ IPZZ-860 — 1 hit(s)</span></div>
+              <div style="padding:6px;background:#0d0d0d;">
+                <div style="background:#161616;border:1px solid #2a2a2a;border-radius:4px;padding:8px 10px;">
+                  <div style="color:#fff;font-weight:600;font-size:12px;">IPZZ-860 [4K].mkv</div>
+                  <div style="color:#aaa;font-size:11px;font-family:Consolas,monospace;margin:3px 0;"><span style="color:#555;font-weight:600;">Path:</span> cq:JAV/ClearJAV/...</div>
+                  <div style="display:flex;align-items:center;gap:8px;font-size:10px;">
+                    <span style="background:#2a2a1a;color:#ffcc44;padding:1px 6px;border-radius:10px;font-weight:600;letter-spacing:.3px;">TARGET</span>
+                    <span style="color:#6ec1ff;font-weight:600;">5.93 GiB</span>
+                  </div>
+                </div>
+              </div>
+              <div style="height:3px;background:#222;"><div id="overlay-preview-bar" style="height:100%;background:linear-gradient(90deg,#6ec1ff,#66dd66);transform-origin:left;transform:scaleX(1);"></div></div>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <!-- NO MATCH tab -->
+      <div class="otab-panel" id="otab-nomatch">
+        <label style="margin-bottom:10px;display:flex;align-items:center;gap:10px;">
+          <input type="checkbox" id="noMatchOverlay"> Show overlay on no match
+          <span class="sublabel" style="margin:0;">Off by default. Auto-check only.</span>
+        </label>
+
+        <div class="fieldset" id="no-match-fieldset">
+          <div style="display:flex;gap:14px;align-items:center;flex-wrap:wrap;">
+            <div>
+              <div style="font-size:11px;color:#888;margin-bottom:4px;">Position</div>
+              <div class="radio-group" id="noMatchPositionGroup" style="margin:0;">
+                <label><input type="radio" name="noMatchPosition" value="top-left"> Top-Left</label>
+                <label><input type="radio" name="noMatchPosition" value="top-right" checked> Top-Right</label>
+                <label><input type="radio" name="noMatchPosition" value="bottom-left"> Bottom-Left</label>
+                <label><input type="radio" name="noMatchPosition" value="bottom-right"> Bottom-Right</label>
+              </div>
+            </div>
+            <div>
+              <div style="font-size:11px;color:#888;margin-bottom:4px;">Duration (sec)</div>
+              <input type="number" id="noMatchDuration" value="5" min="1" max="60" step="1" style="width:80px;">
+            </div>
+          </div>
+          <label style="margin-top:10px;display:flex;align-items:center;gap:10px;">
+            <input type="checkbox" id="noMatchGlow"> Subtle glow
+            <input type="color" id="noMatchGlowColor" value="#ff6666" style="width:36px;height:24px;padding:0;cursor:pointer;" title="Glow color">
+          </label>
+          <div style="margin-top:10px;padding:10px;background:#101010;border:1px solid #232323;border-radius:4px;display:grid;grid-template-columns:90px 1fr 50px;gap:8px;align-items:center;font-size:11px;">
+            <span style="color:#888;">Blur (soft)</span>
+            <input type="range" id="noMatchGlowBlur" min="0" max="60" step="1" value="10" style="width:100%;">
+            <span id="noMatchGlowBlurVal" style="color:#ff6666;text-align:right;font-family:Consolas,monospace;">10 px</span>
+            <span style="color:#888;">Spread (size)</span>
+            <input type="range" id="noMatchGlowSpread" min="0" max="40" step="1" value="0" style="width:100%;">
+            <span id="noMatchGlowSpreadVal" style="color:#ff6666;text-align:right;font-family:Consolas,monospace;">0 px</span>
+            <span style="color:#888;">Opacity</span>
+            <input type="range" id="noMatchGlowOpacity" min="0.05" max="1" step="0.05" value="0.35" style="width:100%;">
+            <span id="noMatchGlowOpacityVal" style="color:#ff6666;text-align:right;font-family:Consolas,monospace;">0.35</span>
+          </div>
+          <div style="margin-top:8px;display:flex;justify-content:flex-end;">
+            <button id="no-match-reset" type="button" style="font-size:11px;padding:4px 10px;">Reset</button>
+          </div>
+        </div>
+
+        <div style="margin-top:12px;border-top:1px solid #222;padding-top:12px;">
+          <div style="font-size:11px;color:#888;margin-bottom:8px;display:flex;justify-content:space-between;align-items:center;">
+            <span>Preview <span id="no-match-preview-pos" style="color:#ff6666;">— top-right</span></span>
+            <button id="no-match-preview-replay" type="button" style="font-size:11px;padding:2px 8px;">Replay</button>
+          </div>
+          <div id="no-match-preview-stage" style="background:#080808;border:1px dashed #2a2a2a;border-radius:4px;padding:18px;display:flex;justify-content:flex-end;align-items:flex-start;min-height:90px;position:relative;">
+            <div id="no-match-preview" style="width:280px;background:#1a1a1a;color:#ddd;border:1px solid #2a2a2a;border-radius:6px;font-size:12px;overflow:hidden;box-shadow:0 6px 20px rgba(0,0,0,.55);">
+              <div style="padding:6px 10px;background:#3a1e1e;color:#faa;font-weight:600;font-size:12px;">✗ START-489 — NOT IN LIBRARY</div>
+              <div style="padding:8px 12px;background:#0d0d0d;color:#aaa;font-size:11px;font-family:Consolas,monospace;word-break:break-all;"><span style="color:#555;font-weight:600;">Scanned:</span> cq:JAV</div>
+              <div style="height:3px;background:#222;"><div id="no-match-preview-bar" style="height:100%;background:linear-gradient(90deg,#ff6666,#ff8c42);transform-origin:left;transform:scaleX(1);"></div></div>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <div class="actions">
+        <button class="primary save-btn">SAVE</button>
+        <span class="saved">Saved.</span>
+      </div>
+    </div>
+
+    <!-- SITE ADAPTERS -->
+    <div class="pane" id="pane-adapters">
+      <div class="pane-head">
+        <h1>Site Extraction</h1>
+        <div class="pdesc">For sites where the JAV ID isn't in the page title, point at a DOM element. Selector runs <code>document.querySelector</code> and extracts <code>textContent</code>.</div>
+      </div>
+      <div id="adapter-summary" class="section-note"></div>
+
+      <table class="adapters" id="adapters">
+        <thead><tr><th>Host pattern</th><th>CSS selector(s)</th><th></th></tr></thead>
+        <tbody></tbody>
+      </table>
+
+      <div class="fieldset" style="margin-top:12px;">
+        <div class="ftitle">Built-in presets</div>
+        <div style="font-family:Consolas,monospace;font-size:11px;color:#888;line-height:1.5;word-break:break-all;">
+          <div><span style="color:#aaa;">clearjav.com</span> → <code>div.meta-chip &gt; h3.meta-chip__value</code></div>
+        </div>
+      </div>
+
+      <div style="display:flex;gap:8px;margin-top:10px;align-items:center;">
+        <button id="add-adapter">+ Add Row</button>
+        <button id="pick-element">Pick Element</button>
+        <button id="test-active-page">Test Active Page</button>
+        <button id="validate-adapters" type="button">Validate Rows</button>
+        <span id="picker-status" style="color:#888;font-size:11px;"></span>
+      </div>
+
+      <div id="adapter-test-result" class="fieldset" style="display:none;margin-top:14px;">
+        <div class="ftitle">Active page extraction bench</div>
+        <div id="adapter-test-output" style="font-family:Consolas,monospace;font-size:11px;color:#aaa;line-height:1.5;word-break:break-all;"></div>
+      </div>
+
+      <div class="actions">
+        <button class="primary save-btn">SAVE</button>
+        <span class="saved">Saved.</span>
+      </div>
+    </div>
+
+    <!-- ID RULES -->
+    <div class="pane" id="pane-normalizers">
+      <div class="pane-head">
+        <h1>ID Rules</h1>
+        <div class="pdesc">Normalize odd IDs and teach rc-jav how multipart filename suffixes should stay distinct.</div>
+      </div>
+      <div id="normalizer-summary" class="section-note"></div>
+
+      <div class="fieldset">
+        <div class="ftitle">Built-in ID rules</div>
+        <div style="font-size:11px;color:#888;line-height:1.5;">
+          <div><code>FC2-?PPV-?(\d{4,})</code> → <code>FC2-PPV-$1</code>
+            <span style="color:#666;"> — handles <code>FC2PPV4903171</code>, <code>FC2-PPV4903171</code>, <code>FC2-PPV-4903171</code></span></div>
+          <div><code>FC2-(\d{4,})</code> → <code>FC2-PPV-$1</code>
+            <span style="color:#666;"> — handles bare site labels like <code>FC2-1841460</code></span></div>
+          <div><code>_A</code> / <code>_B</code> multipart suffixes are distinct parts in rc-jav duplicate/cache ID detection.</div>
+        </div>
+      </div>
+
+      <div class="fieldset" style="margin-top:14px;">
+        <div class="ftitle">Test ID extraction</div>
+        <div class="help">Paste a page title, DOM text, URL fragment, or filename. Uses the current custom normalizer rows below plus built-in extraction rules.</div>
+        <div style="display:grid;grid-template-columns:1fr 120px;gap:8px;align-items:center;">
+          <input type="text" id="norm-test-in" placeholder="paste a sample page title or filename">
+          <button id="norm-test-run">Test Text</button>
+        </div>
+        <div id="norm-test-out" style="margin-top:8px;font-family:Consolas,monospace;font-size:12px;color:#aaa;"></div>
+      </div>
+
+      <div class="fieldset">
+        <div class="ftitle">Custom ID normalizers</div>
+        <table class="adapters" id="normalizers">
+          <thead><tr><th>Pattern (regex)</th><th>Replacement</th><th></th></tr></thead>
+          <tbody></tbody>
+        </table>
+
+        <div style="display:flex;gap:8px;margin-top:10px;align-items:center;">
+          <button id="add-normalizer">+ Add Row</button>
+          <button id="validate-normalizers" type="button">Validate Regex</button>
+          <span id="normalizer-status" class="muted"></span>
+        </div>
+      </div>
+
+      <div class="fieldset">
+        <div class="ftitle">Part detectors</div>
+        <div class="help">Built-in and custom Python regexes run against the filename stem. Capture group 1 must be the part number or a single part letter. Built-ins are shown here so you can see what is already covered before adding a custom detector.</div>
+        <div class="muted" style="margin:0 0 7px;">Built in</div>
+        <div id="builtin-part-detectors" class="part-detector-list" style="margin-bottom:12px;"></div>
+        <div class="muted" style="margin:0 0 7px;">Custom</div>
+        <div id="part-detectors" class="part-detector-list"></div>
+        <div class="button-row" style="margin-top:9px;">
+          <button id="add-part-detector" type="button">+ Add Detector</button>
+        </div>
+        <div class="help">Host searches and cache rebuilds receive these saved rules. Direct CLI use can store the same list as <code>part_patterns</code> in <code>config.json</code> or pass repeatable <code>--part-pattern</code>.</div>
+      </div>
+
+      <div class="actions">
+        <button class="primary save-btn">SAVE</button>
+        <span class="saved">Saved.</span>
+      </div>
+    </div>
+
+    <!-- CACHE & SCANS -->
+    <div class="pane" id="pane-search">
+      <div class="pane-head">
+        <h1>Cache &amp; Scans</h1>
+        <div class="pdesc">Choose lookup mode, inspect cache state, and run cache rebuild jobs.</div>
+      </div>
+      <div id="search-summary" class="section-note"></div>
+
+      <div class="fieldset">
+        <div class="ftitle">Lookup mode</div>
+        <div class="help">Quick mode bypasses cache and uses <code>rclone --include</code> directly — fastest for single-ID lookups. ~1–2s per call. Disable to use the cache (faster on warm cache, requires <code>--scan</code> to keep fresh).</div>
+        <label><input type="checkbox" id="quickMode"> Use --quick mode (live rclone lookup, no cache)</label>
+      </div>
+
+      <div class="fieldset">
+        <div class="ftitle">Cache status</div>
+        <div class="help">Inspect the current <code>cache.json</code> remotes, scan times, file counts, and skipped filename samples.</div>
+        <div class="cache-freshness">
+          <label>Stale after
+            <input type="number" id="cacheStaleHours" value="24" min="1" max="8760" step="1">
+            hours
+          </label>
+          <span class="sublabel">Used for cache warnings in the extension. Freshness does not change search results.</span>
+        </div>
+        <div class="button-row">
+          <button id="cache-status-run" type="button">Check Cache</button>
+        </div>
+        <div id="cache-status-results" class="mono-output"></div>
+      </div>
+
+      <div class="fieldset">
+        <div class="ftitle">Cache rebuild</div>
+        <div class="help">Refresh the cache from the configured scan roots. Incremental rebuilds only ask rclone for recently changed files.</div>
+        <div class="button-row">
+          <select id="cache-rebuild-mode">
+            <option value="">Full Rebuild</option>
+            <option value="24h">Update last 24h</option>
+            <option value="7d">Update last 7d</option>
+          </select>
+          <button id="cache-rebuild-run" type="button">Rebuild Cache</button>
+        </div>
+      </div>
+
+      <div class="fieldset">
+        <div class="ftitle">Scan job</div>
+        <div class="help">Follow the current or last cache scan job and clear old job history after it is no longer useful.</div>
+        <div class="button-row">
+          <button id="scan-job-clear" type="button" style="margin-left:auto;">Clear Job</button>
+        </div>
+        <div id="scan-job-results" class="mono-output"></div>
+      </div>
+
+      <div class="actions">
+        <button class="primary save-btn">SAVE</button>
+        <span class="saved">Saved.</span>
+      </div>
+    </div>
+
+    <!-- LIBRARY REVIEW -->
+    <div class="pane" id="pane-maintenance">
+      <div class="pane-head">
+        <h1>Library Review</h1>
+        <div class="pdesc">Review duplicate groups, check IDs in bulk, and fix non-canonical filenames in your library.</div>
+      </div>
+
+      <div class="fieldset">
+          <div class="ftitle">Duplicate review</div>
+          <div class="help">Review cached duplicate groups before acting. Keep/delete suggestions follow rc-jav rules; catalog rows remain reference-only.</div>
+          <div class="button-row">
+            <button id="dupe-review-run" type="button">Review Cached Duplicates</button>
+          </div>
+          <div id="dupe-review-results" class="mono-output">Review opens in a focused window so large duplicate groups do not stretch this page.</div>
+      </div>
+
+      <div class="fieldset">
+          <div class="ftitle">Keep ranking</div>
+          <div class="help">Controls how rc-jav picks the KEEP file when duplicates are found. Changes take effect immediately — no rescan required.</div>
+          <div class="kr-panel">
+            <div class="kr-info">
+              <strong style="color:#93c5fd">How it works:</strong> Video files in <code>VIP folders</code> win first. <code>.ts</code> files rank below other video containers. After that, files within <code>size tolerance</code> of the largest are treated as equal-size, then ranked by
+              <code>format preference</code>. Remaining ties broken by resolution tag, then filename length.
+              With tolerance = 0 (default), size always decides first.
+            </div>
+            <div class="kr-row" style="align-items:flex-start">
+              <span class="kr-label" style="padding-top:6px">VIP folders</span>
+              <div>
+                <div id="kr-vip-list" class="kr-fmt-list"></div>
+                <div class="button-row" style="margin-top:6px;">
+                  <input id="kr-vip-add" type="text" placeholder="ClearJAV or cq:JAV/DirectRips" style="width:220px;">
+                  <button id="kr-vip-add-btn" type="button">Add VIP Folder</button>
+                </div>
+              </div>
+              <span class="kr-unit" style="padding-top:6px">drag to reorder · top wins first · ClearJAV is the default direct-rip VIP folder</span>
+            </div>
+            <div class="kr-row">
+              <span class="kr-label">Size tolerance</span>
+              <input id="kr-tolerance" class="kr-input" type="number" min="0" max="9999" step="1" value="0">
+              <span class="kr-unit">MiB — files within this range of the largest are considered equal-size</span>
+            </div>
+            <div class="kr-row" style="align-items:flex-start">
+              <span class="kr-label" style="padding-top:6px">Format preference</span>
+              <div id="kr-fmt-list" class="kr-fmt-list">
+                <!-- populated by JS -->
+              </div>
+              <span class="kr-unit" style="padding-top:6px">drag to reorder · top = highest priority</span>
+            </div>
+            <div class="kr-row">
+              <span class="kr-label">Tie-breaks</span>
+              <label class="kr-toggle"><input type="checkbox" id="kr-res-tag" checked> Prefer file with resolution tag <code>[1080p]</code></label>
+            </div>
+            <div class="kr-row">
+              <span class="kr-label"></span>
+              <label class="kr-toggle"><input type="checkbox" id="kr-longer-name" checked> Prefer longer filename (more metadata)</label>
+            </div>
+            <div class="kr-save-row">
+              <button id="kr-save" type="button">Save Ranking</button>
+              <span id="kr-save-status" class="kr-save-status"></span>
+            </div>
+          </div>
+      </div>
+
+      <div class="fieldset">
+          <div class="ftitle">Library issues</div>
+          <div class="help">Find files with non-canonical names: bracket-wrapped IDs like <code>[REAL-779].mp4</code> and no-hyphen IDs like <code>MVSD312.avi</code>. Rename suggestions are computed from cache — no network required.</div>
+          <div class="button-row">
+            <button id="library-issues-run" type="button">Review Library Issues</button>
+          </div>
+          <div id="library-issues-results" class="mono-output"></div>
+      </div>
+
+      <div class="fieldset">
+          <div class="ftitle">Bulk ID check</div>
+          <div class="help">Paste IDs separated by lines, commas, or spaces. Uses the current LIVE/CACHE mode and active library profile.</div>
+          <textarea id="bulk-id-input" placeholder="BLK-474&#10;FC2-4865786&#10;PRTD-[027-030]"></textarea>
+          <div class="button-row" style="margin-top:8px;">
+            <button id="bulk-id-run" type="button">Check IDs</button>
+            <button id="bulk-id-clear" type="button">Clear</button>
+          </div>
+          <div id="bulk-id-results" class="mono-output"></div>
+      </div>
+    </div>
+
+    <!-- SETUP -->
+    <div class="pane" id="pane-paths">
+      <div class="pane-head">
+        <h1>Setup</h1>
+        <div class="pdesc">Script location and settings backup. Native host registration + extension ID live in Diagnostics.</div>
+      </div>
+      <div id="paths-summary" class="section-note"></div>
+
+      <div class="fieldset">
+        <div class="ftitle">rc-jav script path</div>
+        <div class="help">Folder containing <code>rc-jav.py</code>, or full file path. Leave blank for the host default.</div>
+        <div class="compact-grid">
+          <input type="text" id="rcjavPath" placeholder="D:\DEV\Project\rclone-jav">
+          <button id="clear-rcjav-path" type="button">Use Default</button>
+        </div>
+        <div class="button-row" style="margin-top:8px;">
+          <button id="check-rcjav-path" type="button">Check Path</button>
+          <span id="path-check-output" class="muted"></span>
+        </div>
+      </div>
+
+      <div id="backup-summary" class="section-note"></div>
+
+      <div class="fieldset">
+        <div class="ftitle">Backup before moving</div>
+        <div class="help">Extension settings and native messaging permissions are tied to the extension ID. Export before moving, reloading, or reinstalling. See <code>docs/EXTENSION_ID.md</code> for the stable-ID workflow.</div>
+        <div class="button-row">
+          <button id="export-settings">Export Settings</button>
+          <button id="import-settings">Import Settings</button>
+          <input type="file" id="import-file" accept=".json,application/json" style="display:none;">
+          <span id="backup-status" style="color:#888;font-size:11px;"></span>
+        </div>
+      </div>
+
+      <div class="actions">
+        <button class="primary save-btn">SAVE</button>
+        <span class="saved">Saved.</span>
+      </div>
+    </div>
+
+    <!-- PROFILES -->
+    <div class="pane" id="pane-profiles">
+      <div class="pane-head">
+        <h1>Library Profiles</h1>
+        <div class="pdesc">Named source and target remote sets for switching libraries from the popup.</div>
+      </div>
+      <div id="profiles-summary" class="section-note"></div>
+
+      <div id="profiles-list" style="margin-bottom:12px;"></div>
+      <div class="button-row">
+        <button id="add-profile" type="button">+ Add Profile</button>
+        <button id="load-remotes" type="button">Load Remotes</button>
+        <span id="profiles-status" class="muted"></span>
+      </div>
+
+      <div class="actions">
+        <button class="primary save-btn">SAVE</button>
+        <span class="saved">Saved.</span>
+      </div>
+    </div>
+
+    <!-- DIAGNOSTICS -->
+    <div class="pane" id="pane-diagnostics">
+      <div class="pane-head">
+        <h1>Diagnostics</h1>
+        <div class="pdesc">Check setup health, runtime dependencies, native host registration, and recent search behavior.</div>
+      </div>
+
+      <div>
+        <div class="fieldset">
+          <div class="ftitle">Setup health</div>
+          <div class="help">Quick read on current lookup mode, pause state, active profile, cache freshness, and native host registration.</div>
+          <div class="button-row">
+            <button id="setup-health-run" type="button">Check Setup Health</button>
+          </div>
+          <div id="setup-health-results" class="mono-output"></div>
+        </div>
+
+        <div id="native-repair-card" class="fieldset" style="display:none;">
+          <div class="ftitle" id="native-repair-title">Native host setup</div>
+          <div id="native-repair-results"></div>
+        </div>
+
+        <div class="fieldset">
+          <div class="ftitle">Runtime</div>
+          <div class="help">Verifies Python, rclone, rc-jav, config, cache, and WinCatalog files.</div>
+          <div class="button-row">
+            <button id="run-diag">Run Diagnostics</button>
+            <button id="run-all-diag" type="button">Run All</button>
+          </div>
+          <div id="diag-results" style="margin-top:14px;"></div>
+        </div>
+
+        <div class="fieldset">
+          <div class="ftitle">Native host registration</div>
+          <div class="help">Checks the manifest, extension ID permission, and Windows registry entries used by Brave/Chrome native messaging.</div>
+          <div class="compact-grid" style="margin-bottom:10px;align-items:center;">
+            <div style="font-family:Consolas,monospace;font-size:12px;color:#bbb;"><span style="color:#888;">Extension ID:&nbsp;</span><span id="diag-extension-id">—</span></div>
+            <button id="diag-copy-extension-id" type="button" style="padding:4px 10px;font-size:11px;">Copy ID</button>
+          </div>
+          <div class="button-row">
+            <button id="host-status-run" type="button">Check Host Registration</button>
+            <button id="host-repair-run" type="button">Repair Registration</button>
+            <button id="host-verify-run" type="button">Verify Registration</button>
+          </div>
+          <div id="host-status-results" style="margin-top:14px;"></div>
+        </div>
+
+      </div>
+    </div>
+
+    <!-- DEBUG TOOLS -->
+    <div class="pane" id="pane-debug">
+      <div class="pane-head">
+        <h1>Debug Tools</h1>
+        <div class="pdesc">Standalone diagnostic surfaces moved out of the main Diagnostics pane. Search troubleshooting bench + recent search/page-check activity log. Not part of the maintenance workflow.</div>
+      </div>
+
+      <div>
+        <div class="fieldset">
+          <div class="ftitle">Search troubleshooting</div>
+          <div class="help">Paste an ID, page title, DOM text, URL fragment, or filename. The bench extracts an ID, then compares LIVE and CACHE lookup paths for that ID under the active library profile.</div>
+          <textarea id="search-bench-input" placeholder="BLK-474&#10;or paste a page title / DOM text / URL containing an ID"></textarea>
+          <div class="button-row" style="margin-top:8px;">
+            <button id="search-bench-run" type="button">Test Search</button>
+            <button id="search-bench-clear" type="button">Clear</button>
+          </div>
+          <div id="search-bench-results" class="mono-output"></div>
+        </div>
+
+        <div class="fieldset">
+          <div class="ftitle">Recent activity</div>
+          <div class="help">Short local history of page checks and popup searches. Stores the extracted ID, outcome, page context, mode, and timing summary. Search-trigger events only — deletion actions are not recorded here.</div>
+          <div class="button-row">
+            <button id="activity-refresh" type="button">Refresh Activity</button>
+            <button id="activity-clear" type="button">Clear Activity</button>
+          </div>
+          <div class="activity-filters" id="activity-filters" aria-label="Recent activity filters">
+            <button class="activity-filter active" type="button" data-activity-filter="all">All</button>
+            <button class="activity-filter" type="button" data-activity-filter="hit">Match</button>
+            <button class="activity-filter" type="button" data-activity-filter="miss">No Match</button>
+            <button class="activity-filter" type="button" data-activity-filter="no_id">No ID</button>
+            <button class="activity-filter" type="button" data-activity-filter="other">Other</button>
+          </div>
+          <div id="activity-results" class="mono-output"></div>
+        </div>
+      </div>
+    </div>
+
+    <!-- DELETION -->
+    <div class="pane" id="pane-deletion">
+      <div class="pane-head">
+        <h1 style="color:#faa;">Deletion</h1>
+        <div class="pdesc">When enabled, the popup adds a delete button for matched files. Every delete still requires typing the exact filename to confirm.</div>
+      </div>
+      <div id="deletion-summary" class="section-note danger"></div>
+
+      <div class="fieldset danger-zone">
+        <div class="ftitle">Enable</div>
+        <label><input type="checkbox" id="enableDelete"> Enable file deletion from popup</label>
+      </div>
+
+      <div class="fieldset danger-zone">
+        <div class="ftitle">Mode</div>
+        <div class="radio-group">
+          <label class="selected" id="deleteModeTrashLbl"><input type="radio" name="deleteMode" id="deleteModeTrash" value="trash" checked> Move To Trash</label>
+          <label id="deleteModePermLbl"><input type="radio" name="deleteMode" id="deleteModePerm" value="permanent"> Permanent Delete</label>
+        </div>
+        <div class="help">Trash mode runs <code>rclone moveto</code> into the trash dir + <code>YYYY-MM-DD/</code> subdir. Reversible until cleared. Permanent runs <code>rclone deletefile</code> — cloud Drives may still keep a 30-day recycle bin.</div>
+      </div>
+
+      <div class="fieldset danger-zone">
+        <div class="ftitle">Trash directory</div>
+        <input type="text" id="trashDir" placeholder="cq:personal-files/.rclone-jav-trash">
+      </div>
+
+      <div class="actions">
+        <button class="primary save-btn">SAVE</button>
+        <span class="saved">Saved.</span>
+      </div>
+    </div>
+
+  </div>
+
+</div>
+</div>
+
+<div id="skipped-modal" class="modal-backdrop" aria-hidden="true">
+  <div class="modal" role="dialog" aria-modal="true" aria-labelledby="skipped-modal-title">
+    <div class="modal-head">
+      <div>
+        <div class="modal-title" id="skipped-modal-title">Skipped IDs</div>
+        <div class="modal-subtitle" id="skipped-modal-subtitle"></div>
+      </div>
+      <button id="skipped-modal-close" type="button" title="Close">x</button>
+    </div>
+    <div class="modal-body">
+      <div id="skipped-modal-summary" class="skip-summary"></div>
+      <div id="skipped-modal-list"></div>
+    </div>
+    <div class="modal-actions">
+      <button id="skipped-modal-copy" type="button">Copy List</button>
+      <button id="skipped-modal-done" type="button">Close</button>
+    </div>
+  </div>
+</div>
+
+<div id="profile-modal" class="modal-backdrop" aria-hidden="true">
+  <div class="modal" role="dialog" aria-modal="true" aria-labelledby="profile-modal-title">
+    <div class="modal-head">
+      <div>
+        <div class="modal-title" id="profile-modal-title">Library Profile</div>
+        <div class="modal-subtitle">Named source and target remotes for popup library switching.</div>
+      </div>
+      <button id="profile-modal-close" type="button" title="Close">x</button>
+    </div>
+    <div class="modal-body">
+      <div class="modal-field">
+        <label for="profile-modal-name">Profile name</label>
+        <input type="text" id="profile-modal-name" placeholder="ClearJAV">
+      </div>
+      <div class="modal-field">
+        <label>Source remotes</label>
+        <div id="profile-modal-source" class="prof-remote-group"></div>
+      </div>
+      <div class="modal-field">
+        <label>Target remotes</label>
+        <div id="profile-modal-target" class="prof-remote-group"></div>
+      </div>
+      <div id="profile-modal-status" class="muted"></div>
+    </div>
+    <div class="modal-actions">
+      <button id="profile-modal-cancel" type="button">Cancel</button>
+      <button id="profile-modal-save" class="primary" type="button">Save Profile</button>
+    </div>
+  </div>
+</div>
+
+<div id="dupe-review-modal" class="modal-backdrop" aria-hidden="true">
+  <div class="modal" role="dialog" aria-modal="true" aria-labelledby="dupe-review-modal-title">
+    <div class="modal-head">
+      <div>
+        <div class="modal-title" id="dupe-review-modal-title">Duplicate Review</div>
+        <div class="modal-subtitle">Cached duplicate groups and rc-jav keep/delete suggestions.</div>
+      </div>
+      <button id="dupe-review-modal-close" type="button" title="Close">x</button>
+    </div>
+    <div id="dupe-review-modal-body" class="modal-body"></div>
+    <div class="modal-actions">
+      <span id="dupe-review-confirm-status" style="font-size:12px;color:#8888aa;flex:1;"></span>
+      <button id="dupe-review-execute" type="button" disabled>Execute Deletions (0)</button>
+      <button id="dupe-review-export" type="button" disabled>Export JSON</button>
+      <button id="dupe-review-modal-done" type="button">Close</button>
+    </div>
+  </div>
+</div>
+
+<div id="library-issues-modal" class="modal-backdrop" aria-hidden="true">
+  <div class="modal" role="dialog" aria-modal="true" aria-labelledby="library-issues-modal-title">
+    <div class="modal-head">
+      <div>
+        <div class="modal-title" id="library-issues-modal-title">Library Issues</div>
+        <div class="modal-subtitle">Non-canonical filenames detected in cache. Rename to fix.</div>
+      </div>
+      <button id="library-issues-modal-close" type="button" title="Close">x</button>
+    </div>
+    <div id="library-issues-modal-body" class="modal-body"></div>
+    <div class="modal-actions">
+      <span id="library-issues-rename-status" style="font-size:12px;color:#8888aa;flex:1;"></span>
+      <button id="library-issues-rename-all" type="button" disabled>Rename All</button>
+      <button id="library-issues-modal-done" type="button">Close</button>
+    </div>
+  </div>
+</div>
+
+<div id="import-modal" class="modal-backdrop" aria-hidden="true">
+  <div class="modal" role="dialog" aria-modal="true" aria-labelledby="import-modal-title">
+    <div class="modal-head">
+      <div>
+        <div class="modal-title" id="import-modal-title">Import Settings</div>
+        <div class="modal-subtitle" id="import-modal-subtitle"></div>
+      </div>
+      <button id="import-modal-close" type="button" title="Close">x</button>
+    </div>
+    <div id="import-modal-body" class="modal-body"></div>
+    <div class="modal-actions">
+      <button id="import-modal-cancel" type="button">Cancel</button>
+      <button id="import-modal-confirm" class="primary" type="button">Import Settings</button>
+    </div>
+  </div>
+</div>
+
+<div id="delete-enable-modal" class="modal-backdrop" aria-hidden="true">
+  <div class="modal" role="dialog" aria-modal="true" aria-labelledby="delete-enable-modal-title">
+    <div class="modal-head">
+      <div>
+        <div class="modal-title" id="delete-enable-modal-title">Enable Deletion</div>
+        <div class="modal-subtitle">This exposes delete controls in the popup.</div>
+      </div>
+      <button id="delete-enable-modal-close" type="button" title="Close">x</button>
+    </div>
+    <div class="modal-body">
+      <div class="modal-confirm">Matched files can be moved to trash or permanently deleted from the popup after this setting is saved. Popup deletion still requires typing the exact filename before rc-jav acts.</div>
+    </div>
+    <div class="modal-actions">
+      <button id="delete-enable-modal-cancel" type="button">Cancel</button>
+      <button id="delete-enable-modal-confirm" class="primary" type="button">Enable Deletion</button>
+    </div>
+  </div>
+</div>
+
+<script src="options.js"></script>
+</body>
+</html>
diff --git a/options.js b/options.js
new file mode 100644
index 0000000..cde48b0
--- /dev/null
+++ b/options.js
@@ -0,0 +1,3133 @@
+const KEYS = [
+  "autoEveryPage",
+  "autoKnownSites",
+  "autoPageLoad",
+  "autoSpaNavigation",
+  "toolbarClick",
+  "contextMenu",
+  "keyboardShortcut",
+];
+
+// MUST match DEFAULT_SETTINGS in background.js.
+const DEFAULT_TRIGGERS = {
+  autoEveryPage: false,
+  autoKnownSites: false,
+  autoPageLoad: true,
+  autoSpaNavigation: true,
+  toolbarClick: true,
+  contextMenu: true,
+  keyboardShortcut: true,
+};
+
+// ---------- sidebar nav ----------
+function activatePane(pane) {
+  if (pane === "backup") pane = "paths";
+  if (pane === "review") pane = "maintenance";
+  const item = document.querySelector(`.side .item[data-pane="${pane}"]`) || document.querySelector('.side .item[data-pane="triggers"]');
+  if (!item) return;
+  document.querySelectorAll(".side .item").forEach((i) => i.classList.remove("active"));
+  item.classList.add("active");
+  document.querySelectorAll(".pane").forEach((p) => p.classList.remove("active"));
+  const paneEl = document.getElementById("pane-" + item.dataset.pane);
+  if (paneEl) paneEl.classList.add("active");
+}
+
+for (const item of document.querySelectorAll(".side .item")) {
+  item.addEventListener("click", async () => {
+    activatePane(item.dataset.pane);
+    await chrome.storage.local.set({ optionsActivePane: item.dataset.pane });
+  });
+}
+
+function getActionScrollContainer(element) {
+  for (let node = element?.parentElement; node; node = node.parentElement) {
+    const overflowY = getComputedStyle(node).overflowY;
+    if ((overflowY === "auto" || overflowY === "scroll") && node.scrollHeight > node.clientHeight) {
+      return node;
+    }
+  }
+  return document.scrollingElement || document.documentElement;
+}
+
+function nextAnimationFrame() {
+  return new Promise((resolve) => requestAnimationFrame(resolve));
+}
+
+function openModal(id) {
+  const modal = document.getElementById(id);
+  if (!modal) return;
+  modal.classList.add("open");
+  modal.setAttribute("aria-hidden", "false");
+}
+
+function closeModal(id) {
+  const modal = document.getElementById(id);
+  if (!modal) return;
+  modal.classList.remove("open");
+  modal.setAttribute("aria-hidden", "true");
+}
+
+async function keepActionViewport(action, run) {
+  const beforeTop = action?.getBoundingClientRect().top;
+  const scroller = getActionScrollContainer(action);
+  try {
+    return await run();
+  } finally {
+    await nextAnimationFrame();
+    await nextAnimationFrame();
+    if (!action?.isConnected || !Number.isFinite(beforeTop)) return;
+    const delta = action.getBoundingClientRect().top - beforeTop;
+    if (Math.abs(delta) < 1) return;
+    if (scroller === document.scrollingElement || scroller === document.documentElement) {
+      window.scrollBy(0, delta);
+    } else {
+      scroller.scrollTop += delta;
+    }
+  }
+}
+
+// ---------- overlay tabs ----------
+for (const tab of document.querySelectorAll(".otab")) {
+  tab.addEventListener("click", () => {
+    document.querySelectorAll(".otab").forEach((t) => t.classList.remove("active"));
+    document.querySelectorAll(".otab-panel").forEach((p) => p.classList.remove("active"));
+    tab.classList.add("active");
+    document.getElementById("otab-" + tab.dataset.otab).classList.add("active");
+  });
+}
+
+// ---------- settings load / save ----------
+
+async function load() {
+  const { settings = {} } = await chrome.storage.sync.get("settings");
+  const t = Object.assign({}, DEFAULT_TRIGGERS, settings.triggers || {});
+  for (const k of KEYS) document.getElementById(k).checked = !!t[k];
+  document.getElementById("quickMode").checked = settings.quickMode !== false;
+  document.getElementById("cacheStaleHours").value = Math.max(1, Number(settings.cacheStaleHours) || 24);
+  document.getElementById("showOverlay").checked = settings.showOverlay !== false;
+  // Overlay options
+  const pos = settings.overlayPosition || "top-right";
+  for (const r of document.querySelectorAll('input[name="overlayPosition"]')) {
+    r.checked = r.value === pos;
+  }
+  syncOverlayPosChips();
+  document.getElementById("overlayDuration").value = settings.overlayDuration || 5;
+  document.getElementById("overlayGlow").checked = !!settings.overlayGlow;
+  document.getElementById("overlayGlowColor").value = settings.overlayGlowColor || "#6ec1ff";
+  document.getElementById("overlayGlowBlur").value = settings.overlayGlowBlur ?? 10;
+  document.getElementById("overlayGlowSpread").value = settings.overlayGlowSpread ?? 0;
+  document.getElementById("overlayGlowOpacity").value = settings.overlayGlowOpacity ?? 0.35;
+  // no-match overlay
+  document.getElementById("noMatchOverlay").checked = !!settings.noMatchOverlay;
+  const nmPos = settings.noMatchPosition || "top-right";
+  for (const r of document.querySelectorAll('input[name="noMatchPosition"]')) {
+    r.checked = r.value === nmPos;
+  }
+  syncNoMatchPosChips();
+  document.getElementById("noMatchDuration").value = settings.noMatchDuration || 5;
+  document.getElementById("noMatchGlow").checked = !!settings.noMatchGlow;
+  document.getElementById("noMatchGlowColor").value = settings.noMatchGlowColor || "#ff6666";
+  document.getElementById("noMatchGlowBlur").value = settings.noMatchGlowBlur ?? 10;
+  document.getElementById("noMatchGlowSpread").value = settings.noMatchGlowSpread ?? 0;
+  document.getElementById("noMatchGlowOpacity").value = settings.noMatchGlowOpacity ?? 0.35;
+  if (typeof updateOverlayPreview === "function") updateOverlayPreview();
+  if (typeof updateNoMatchPreview === "function") updateNoMatchPreview();
+  if (typeof updateMutualExclusion === "function") updateMutualExclusion();
+  document.getElementById("knownSitePatterns").value = (settings.knownSitePatterns || []).join("\n");
+  renderAdapters(settings.siteAdapters || []);
+  renderNormalizers(settings.idNormalizers || []);
+  renderPartDetectors(settings.partPatterns || []);
+  document.getElementById("enableDelete").checked = !!settings.enableDelete;
+  const mode = settings.deleteMode === "permanent" ? "permanent" : "trash";
+  document.getElementById("deleteModeTrash").checked = mode === "trash";
+  document.getElementById("deleteModePerm").checked = mode === "permanent";
+  syncRadioChips();
+  document.getElementById("trashDir").value = settings.trashDir || "cq:personal-files/.rclone-jav-trash";
+  document.getElementById("rcjavPath").value = settings.rcjavPath || "";
+  renderProfiles(settings.profiles || []);
+  updateSectionSummaries();
+  syncDeletionControls();
+}
+
+async function save(e) {
+  const { settings: existingSettings = {} } = await chrome.storage.sync.get("settings");
+  const triggers = {};
+  for (const k of KEYS) triggers[k] = document.getElementById(k).checked;
+  const knownSitePatterns = document.getElementById("knownSitePatterns").value
+    .split(/[\n,]/).map((s) => s.trim()).filter(Boolean);
+  const quickMode = document.getElementById("quickMode").checked;
+  const cacheStaleHours = Math.max(1, Math.min(8760, parseInt(document.getElementById("cacheStaleHours").value, 10) || 24));
+  const showOverlay = document.getElementById("showOverlay").checked;
+  const overlayPosition = (document.querySelector('input[name="overlayPosition"]:checked') || {}).value || "top-right";
+  const overlayDuration = Math.max(1, parseInt(document.getElementById("overlayDuration").value, 10) || 5);
+  const overlayGlow = document.getElementById("overlayGlow").checked;
+  const overlayGlowColor = document.getElementById("overlayGlowColor").value || "#6ec1ff";
+  const overlayGlowBlur = parseInt(document.getElementById("overlayGlowBlur").value, 10);
+  const overlayGlowSpread = parseInt(document.getElementById("overlayGlowSpread").value, 10);
+  const overlayGlowOpacity = parseFloat(document.getElementById("overlayGlowOpacity").value);
+  const noMatchOverlay = document.getElementById("noMatchOverlay").checked;
+  const noMatchPosition = (document.querySelector('input[name="noMatchPosition"]:checked') || {}).value || "top-right";
+  const noMatchDuration = Math.max(1, parseInt(document.getElementById("noMatchDuration").value, 10) || 5);
+  const noMatchGlow = document.getElementById("noMatchGlow").checked;
+  const noMatchGlowColor = document.getElementById("noMatchGlowColor").value || "#ff6666";
+  const noMatchGlowBlur = parseInt(document.getElementById("noMatchGlowBlur").value, 10);
+  const noMatchGlowSpread = parseInt(document.getElementById("noMatchGlowSpread").value, 10);
+  const noMatchGlowOpacity = parseFloat(document.getElementById("noMatchGlowOpacity").value);
+  const siteAdapters = readAdapters();
+  const idNormalizers = readNormalizers();
+  const partPatterns = readPartDetectors();
+  const enableDelete = document.getElementById("enableDelete").checked;
+  const deleteMode = document.getElementById("deleteModePerm").checked ? "permanent" : "trash";
+  const trashDir = document.getElementById("trashDir").value.trim() || "cq:personal-files/.rclone-jav-trash";
+  const rcjavPath = document.getElementById("rcjavPath").value.trim();
+  const payload = {
+    triggers, knownSitePatterns, quickMode, cacheStaleHours,
+    showOverlay, overlayPosition, overlayDuration, overlayGlow, overlayGlowColor, overlayGlowBlur, overlayGlowSpread, overlayGlowOpacity,
+    noMatchOverlay, noMatchPosition, noMatchDuration, noMatchGlow, noMatchGlowColor, noMatchGlowBlur, noMatchGlowSpread, noMatchGlowOpacity,
+    siteAdapters, idNormalizers, partPatterns, enableDelete, deleteMode, trashDir, rcjavPath,
+    profiles: readProfiles(),
+    activeProfile: existingSettings.activeProfile || "",
+    scanPaused: !!existingSettings.scanPaused,
+  };
+  const btn = e && e.target ? e.target : null;
+  const saved = btn && btn.nextElementSibling;
+  try {
+    await chrome.storage.sync.set({ settings: payload });
+  } catch (err) {
+    // chrome.storage.sync has 8 KB/item + 100 KB total quota. Long adapter or
+    // normalizer lists can blow it; without this try/catch the rejection is
+    // silently swallowed and the "Saved." chip never appears.
+    if (saved && saved.classList.contains("saved")) {
+      saved.textContent = "Save failed: " + (err.message || String(err));
+      saved.classList.add("show", "error");
+      setTimeout(() => { saved.classList.remove("show", "error"); saved.textContent = "Saved."; }, 4000);
+    } else {
+      alert("Failed to save settings: " + (err.message || String(err)));
+    }
+    return;
+  }
+  chrome.runtime.sendMessage({ type: "settings-changed" });
+  updateSectionSummaries();
+
+  // Show "Saved." chip on the button that triggered this
+  if (saved && saved.classList.contains("saved")) {
+    saved.classList.add("show");
+    setTimeout(() => saved.classList.remove("show"), 1500);
+  }
+}
+
+for (const btn of document.querySelectorAll(".save-btn")) {
+  btn.addEventListener("click", save);
+}
+
+function plural(n, word) {
+  return `${n} ${word}${n === 1 ? "" : "s"}`;
+}
+
+function setNote(id, html, kind = "") {
+  const el = document.getElementById(id);
+  if (!el) return;
+  el.className = "section-note" + (kind ? ` ${kind}` : "");
+  el.innerHTML = html;
+}
+
+function updateSectionSummaries() {
+  const knownSites = document.getElementById("knownSitePatterns").value
+    .split(/[\n,]/).map((s) => s.trim()).filter(Boolean);
+  const triggersOn = KEYS.filter((k) => document.getElementById(k)?.checked);
+  const autoOn = document.getElementById("autoEveryPage").checked || document.getElementById("autoKnownSites").checked;
+  setNote("trigger-summary",
+    `${autoOn ? "Auto-check is enabled" : "Auto-check is off"} · ${plural(knownSites.length, "known site")} · ${plural(triggersOn.length, "manual/navigation control")} enabled`,
+    autoOn ? "" : "warn");
+
+  const match = document.getElementById("showOverlay").checked;
+  const noMatch = document.getElementById("noMatchOverlay").checked;
+  setNote("overlay-summary", `Match overlay ${match ? "on" : "off"} · no-match overlay ${noMatch ? "on" : "off"} · positions are kept separate to avoid overlap`, match || noMatch ? "" : "warn");
+
+  const adapters = readAdapters();
+  setNote("adapter-summary", `${plural(adapters.length, "custom adapter")} configured · built-in ClearJAV preset always runs`, adapters.length ? "" : "info");
+
+  const normalizers = readNormalizers();
+  const partPatterns = readPartDetectors();
+  setNote("normalizer-summary", `${plural(normalizers.length, "custom normalizer")} · ${plural(partPatterns.length, "custom part detector")} · built-in FC2 and multipart rules active`, normalizers.length || partPatterns.length ? "" : "info");
+
+  const quick = document.getElementById("quickMode").checked;
+  setNote("search-summary", quick ? "LIVE mode: single-ID lookups query rclone directly and bypass cache." : "CACHE mode: lookups use cache.json; rebuild cache after library or ID-normalization changes.");
+
+  const path = document.getElementById("rcjavPath").value.trim();
+  setNote("paths-summary", path ? `Using extension override: <code>${escapeHtml(path)}</code>` : "Using native host default rc-jav path.", path ? "" : "info");
+
+  const profiles = readProfiles();
+  setNote("profiles-summary", profiles.length ? `${plural(profiles.length, "profile")} configured. Empty source/target lists inherit config.json defaults.` : "No profiles configured. Popup searches use rc-jav config.json defaults.", profiles.length ? "" : "info");
+
+  const settingCount = Object.keys(SETTINGS_SCHEMA).length;
+  setNote("backup-summary", `Backups include ${settingCount} recognized settings keys. Export before moving the extension or changing its ID.`, "info");
+
+  const deleteOn = document.getElementById("enableDelete").checked;
+  const mode = document.getElementById("deleteModePerm").checked ? "permanent delete" : "trash mode";
+  setNote("deletion-summary", deleteOn ? `Deletion is enabled in ${mode}. Popup confirmation still requires typing the exact filename.` : "Deletion is disabled. Popup delete controls stay hidden.", deleteOn ? "danger" : "");
+}
+
+function syncDeletionControls() {
+  const enabled = document.getElementById("enableDelete").checked;
+  for (const id of ["deleteModeTrash", "deleteModePerm", "trashDir"]) {
+    const el = document.getElementById(id);
+    if (el) el.disabled = !enabled;
+  }
+  for (const el of [document.getElementById("deleteModeTrashLbl")?.closest(".fieldset"), document.getElementById("trashDir")?.closest(".fieldset")]) {
+    if (el) el.classList.toggle("disabled-soft", !enabled);
+  }
+}
+
+document.getElementById("enableDelete").addEventListener("change", (event) => {
+  if (!event.target.checked) return;
+  event.target.checked = false;
+  syncDeletionControls();
+  updateSectionSummaries();
+  openModal("delete-enable-modal");
+});
+function closeDeleteEnableModal() {
+  closeModal("delete-enable-modal");
+}
+document.getElementById("delete-enable-modal-confirm").addEventListener("click", () => {
+  document.getElementById("enableDelete").checked = true;
+  closeDeleteEnableModal();
+  syncDeletionControls();
+  updateSectionSummaries();
+});
+for (const id of ["delete-enable-modal-close", "delete-enable-modal-cancel"]) {
+  document.getElementById(id).addEventListener("click", closeDeleteEnableModal);
+}
+document.getElementById("delete-enable-modal").addEventListener("click", (event) => {
+  if (event.target.id === "delete-enable-modal") closeDeleteEnableModal();
+});
+
+document.addEventListener("input", (e) => {
+  if (e.target && e.target.closest(".pane")) updateSectionSummaries();
+});
+document.addEventListener("change", (e) => {
+  if (e.target && e.target.closest(".pane")) {
+    if (e.target.id === "enableDelete") syncDeletionControls();
+    updateSectionSummaries();
+  }
+});
+
+// ---------- backup & restore ----------
+
+document.getElementById("export-settings").addEventListener("click", async () => {
+  const { settings = {} } = await chrome.storage.sync.get("settings");
+  const payload = {
+    _meta: { app: "rclonex", exported_at: new Date().toISOString(), version: 1 },
+    settings,
+  };
+  const blob = new Blob([JSON.stringify(payload, null, 2)], { type: "application/json" });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  a.href = url;
+  a.download = `rclonex-settings-${stamp}.json`;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+  URL.revokeObjectURL(url);
+  setBackupStatus("exported.", "ok");
+});
+
+document.getElementById("import-settings").addEventListener("click", () => {
+  document.getElementById("import-file").click();
+});
+
+// Allowlist of settings keys with their expected primitive types. Imports
+// containing any other key are dropped silently; primitives must match.
+// Nested objects (triggers, siteAdapters[].*) get a recursive shallow check.
+const SETTINGS_SCHEMA = {
+  triggers: "object",
+  knownSitePatterns: "array",
+  quickMode: "boolean",
+  cacheStaleHours: "number",
+  scanPaused: "boolean",
+  rcjavPath: "string",
+  showOverlay: "boolean",
+  overlayPosition: "string",
+  overlayDuration: "number",
+  overlayGlow: "boolean",
+  overlayGlowColor: "string",
+  overlayGlowBlur: "number",
+  overlayGlowSpread: "number",
+  overlayGlowOpacity: "number",
+  noMatchOverlay: "boolean",
+  noMatchPosition: "string",
+  noMatchDuration: "number",
+  noMatchGlow: "boolean",
+  noMatchGlowColor: "string",
+  noMatchGlowBlur: "number",
+  noMatchGlowSpread: "number",
+  noMatchGlowOpacity: "number",
+  enableDelete: "boolean",
+  deleteMode: "string",
+  trashDir: "string",
+  idNormalizers: "array",
+  partPatterns: "array",
+  siteAdapters: "array",
+  profiles: "array",
+  activeProfile: "string",
+};
+
+function _typeOf(v) {
+  if (Array.isArray(v)) return "array";
+  if (v === null) return "null";
+  return typeof v;
+}
+
+function sanitizeImportedSettings(incoming) {
+  if (typeof incoming !== "object" || incoming === null || Array.isArray(incoming)) {
+    throw new Error("settings must be a JSON object");
+  }
+  const out = {};
+  const dropped = [];
+  for (const [k, v] of Object.entries(incoming)) {
+    const expected = SETTINGS_SCHEMA[k];
+    if (!expected) { dropped.push(k); continue; }
+    if (_typeOf(v) !== expected) { dropped.push(`${k}(wrong type)`); continue; }
+    out[k] = v;
+  }
+  return { sanitized: out, dropped };
+}
+
+let pendingImport = null;
+
+function closeImportModal() {
+  pendingImport = null;
+  closeModal("import-modal");
+}
+
+function openImportModal(fileName, sanitized, dropped) {
+  pendingImport = { sanitized, dropped };
+  document.getElementById("import-modal-subtitle").textContent = fileName || "settings JSON";
+  document.getElementById("import-modal-body").innerHTML = `
+    <div class="modal-help">Review this import before it replaces the current extension settings.</div>
+    <div class="diag-row warn"><span class="icon">!</span><span class="name">Overwrite</span><span class="detail">Current settings will be replaced by ${escapeHtml(Object.keys(sanitized).length)} imported value(s).</span></div>
+    <div class="diag-row info"><span class="icon">i</span><span class="name">Profiles</span><span class="detail">${escapeHtml(Array.isArray(sanitized.profiles) ? `${sanitized.profiles.length} profile(s) in this import` : "No profile list in this import")}</span></div>
+    <div class="diag-row ${sanitized.enableDelete ? "warn" : "info"}"><span class="icon">${sanitized.enableDelete ? "!" : "i"}</span><span class="name">Deletion</span><span class="detail">${escapeHtml(sanitized.enableDelete ? `Enabled in imported settings (${sanitized.deleteMode || "trash"} mode)` : "Not enabled by this import")}</span></div>
+    ${dropped.length ? `<div class="diag-row warn"><span class="icon">!</span><span class="name">Ignored keys</span><span class="detail">${escapeHtml(`${dropped.length}: ${dropped.slice(0, 8).join(", ")}${dropped.length > 8 ? "..." : ""}`)}</span></div>` : `<div class="diag-row ok"><span class="icon">✓</span><span class="name">Schema</span><span class="detail">All imported keys are recognized.</span></div>`}
+  `;
+  openModal("import-modal");
+}
+
+document.getElementById("import-file").addEventListener("change", async (e) => {
+  const file = e.target.files?.[0];
+  if (!file) return;
+  try {
+    const text = await file.text();
+    const data = JSON.parse(text);
+    const incoming = data.settings || data;
+    const { sanitized, dropped } = sanitizeImportedSettings(incoming);
+    if (Object.keys(sanitized).length === 0) {
+      throw new Error("no recognized settings keys in file");
+    }
+    openImportModal(file.name, sanitized, dropped);
+  } catch (err) {
+    setBackupStatus("import failed: " + err.message, "fail");
+  }
+  e.target.value = "";
+});
+
+document.getElementById("import-modal-confirm").addEventListener("click", async () => {
+  if (!pendingImport) return;
+  const { sanitized, dropped } = pendingImport;
+  try {
+    await chrome.storage.sync.set({ settings: sanitized });
+    chrome.runtime.sendMessage({ type: "settings-changed" });
+    closeImportModal();
+    setBackupStatus(`imported${dropped.length ? ` (${dropped.length} key(s) dropped)` : ""}. reloading...`, "ok");
+    setTimeout(() => location.reload(), 600);
+  } catch (err) {
+    setBackupStatus("import failed: " + (err.message || String(err)), "fail");
+  }
+});
+document.getElementById("import-modal-close").addEventListener("click", closeImportModal);
+document.getElementById("import-modal-cancel").addEventListener("click", () => {
+  setBackupStatus("cancelled.", "warn");
+  closeImportModal();
+});
+document.getElementById("import-modal").addEventListener("click", (event) => {
+  if (event.target.id === "import-modal") closeImportModal();
+});
+
+function setBackupStatus(msg, kind) {
+  const el = document.getElementById("backup-status");
+  el.textContent = msg;
+  el.style.color = kind === "ok" ? "#afa" : kind === "fail" ? "#faa" : "#ffa";
+  setTimeout(() => { el.textContent = ""; }, 4000);
+}
+
+function appendListValue(textareaId, value) {
+  const el = document.getElementById(textareaId);
+  const parts = el.value.split(/[\n,]/).map((s) => s.trim()).filter(Boolean);
+  if (!parts.some((p) => p.toLowerCase() === value.toLowerCase())) parts.push(value);
+  el.value = parts.join("\n");
+  updateSectionSummaries();
+}
+
+document.getElementById("add-clearjav-site").addEventListener("click", () => {
+  appendListValue("knownSitePatterns", "clearjav.com");
+  document.getElementById("known-site-status").textContent = "added clearjav.com";
+});
+
+document.getElementById("add-current-site").addEventListener("click", async () => {
+  const status = document.getElementById("known-site-status");
+  status.textContent = "finding current site...";
+  const all = await chrome.tabs.query({});
+  const web = all.filter((t) => t.url && /^https?:/.test(t.url));
+  web.sort((a, b) => (b.lastAccessed || 0) - (a.lastAccessed || 0));
+  const tab = web[0];
+  if (!tab) {
+    status.textContent = "no http/https tab found";
+    return;
+  }
+  try {
+    const host = new URL(tab.url).hostname.replace(/^www\./, "");
+    appendListValue("knownSitePatterns", host);
+    status.textContent = `added ${host}`;
+  } catch {
+    status.textContent = "could not read active site";
+  }
+});
+
+// ---------- cache status ----------
+
+function fmtCacheAge(hours) {
+  if (!Number.isFinite(hours)) return "?";
+  if (hours < 1) return `${Math.round(hours * 60)}m`;
+  if (hours < 24) return `${hours.toFixed(1)}h`;
+  return `${(hours / 24).toFixed(1)}d`;
+}
+
+let _configuredScanRoots = [];
+let _cacheSkippedByRemote = new Map();
+let _skippedModalText = "";
+
+function rememberConfiguredScanRoots(r) {
+  _configuredScanRoots = [
+    ...(r?.configured?.default_source || []),
+    ...(r?.configured?.default_target || []),
+  ];
+}
+
+function setupHealthRow(level, name, detail) {
+  const icon = level === "ok" ? "✓" : level === "warn" ? "!" : level === "fail" ? "✗" : "i";
+  return `<div class="diag-row ${level}"><span class="icon">${icon}</span><span class="name">${escapeHtml(name)}</span><span class="detail">${escapeHtml(detail)}</span></div>`;
+}
+
+function openSkippedModal(remote) {
+  const items = _cacheSkippedByRemote.get(remote) || [];
+  const summary = document.getElementById("skipped-modal-summary");
+  const list = document.getElementById("skipped-modal-list");
+  document.getElementById("skipped-modal-subtitle").textContent = `${remote} · ${items.length} skipped`;
+  const reasonCounts = new Map();
+  for (const item of items) reasonCounts.set(item.reason || "unparsed ID", (reasonCounts.get(item.reason || "unparsed ID") || 0) + 1);
+  summary.innerHTML = [...reasonCounts.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .map(([reason, count]) => `<span>${escapeHtml(count)} ${escapeHtml(reason)}</span>`)
+    .join("");
+  list.innerHTML = items.map((item) => `<div class="skip-row">
+    <div class="name">${escapeHtml(item.name || item.path || "?")}</div>
+    <div class="reason">${escapeHtml(item.reason || "unparsed ID")}</div>
+    <div class="path">${escapeHtml(item.path || "")}</div>
+  </div>`).join("") || `<div style="color:#777;">No skipped IDs recorded for this remote.</div>`;
+  _skippedModalText = [
+    `Skipped IDs for ${remote}`,
+    ...items.map((item) => `${item.name || item.path || "?"}\t${item.reason || "unparsed ID"}\t${item.path || ""}`),
+  ].join("\n");
+  openModal("skipped-modal");
+}
+
+function closeSkippedModal() {
+  closeModal("skipped-modal");
+}
+
+document.getElementById("skipped-modal-close").addEventListener("click", closeSkippedModal);
+document.getElementById("skipped-modal-done").addEventListener("click", closeSkippedModal);
+document.getElementById("skipped-modal").addEventListener("click", (event) => {
+  if (event.target.id === "skipped-modal") closeSkippedModal();
+});
+document.getElementById("skipped-modal-copy").addEventListener("click", async () => {
+  if (!_skippedModalText) return;
+  await navigator.clipboard.writeText(_skippedModalText);
+  const btn = document.getElementById("skipped-modal-copy");
+  btn.textContent = "Copied";
+  setTimeout(() => { btn.textContent = "Copy List"; }, 1200);
+});
+
+document.getElementById("setup-health-run").addEventListener("click", (event) =>
+  keepActionViewport(event.currentTarget, async () => {
+    const out = document.getElementById("setup-health-results");
+    clearNativeRepairCard();
+    out.textContent = "checking setup health...";
+    const [settings, cache, host] = await Promise.all([
+      chrome.runtime.sendMessage({ type: "get-settings" }),
+      chrome.runtime.sendMessage({ type: "cache-status" }),
+      chrome.runtime.sendMessage({ type: "host-status" }),
+    ]);
+    const rows = [];
+    const mode = settings?.quickMode !== false ? "LIVE" : "CACHE";
+    rows.push(setupHealthRow(settings?.scanPaused ? "warn" : "ok", "Search state",
+      settings?.scanPaused ? `${mode} mode · scanning paused` : `${mode} mode · scanning enabled`));
+    rows.push(setupHealthRow("info", "Library profile",
+      settings?.activeProfile || "config.json defaults"));
+    const nativeBlocked = [cache, host].find((r) => r && !r.ok && r.error_kind);
+    if (nativeBlocked) await renderNativeMessagingFailure(nativeBlocked);
+    if (!cache?.ok && cache?.error_kind) {
+      rows.push(setupHealthRow("warn", "Cache", "Blocked until native host registration is fixed."));
+    } else if (!cache?.ok) {
+      rows.push(setupHealthRow("fail", "Cache", cache?.error || "cache status unavailable"));
+    } else if (!cache.cache_exists) {
+      rows.push(setupHealthRow("warn", "Cache", "cache.json missing; cached searches need a rebuild"));
+    } else {
+      const remotes = cache.remotes || [];
+      const stale = remotes.filter((r) => r.stale || r.status === "never_scanned");
+      const files = remotes.reduce((sum, r) => sum + Number(r.file_count || 0), 0);
+      rows.push(setupHealthRow(stale.length || (cache.warnings || []).length ? "warn" : "ok", "Cache",
+        `${files.toLocaleString()} files · ${remotes.length} remote(s) · ${stale.length} stale/unscanned`));
+    }
+    if (!host?.ok && host?.error_kind) {
+      rows.push(setupHealthRow("warn", "Native host", "Registration is required before host checks can run."));
+    } else if (!host?.ok) {
+      rows.push(setupHealthRow("fail", "Native host", host?.error || "host status unavailable"));
+    } else {
+      const failed = (host.checks || []).filter((c) => c.status === "fail");
+      rows.push(setupHealthRow(failed.length ? "fail" : "ok", "Native host",
+        failed.length ? `${failed.length} registration check(s) failed; use Diagnostics` : "registration checks passed"));
+    }
+    out.innerHTML = rows.join("");
+  })
+);
+
+document.getElementById("cache-status-run").addEventListener("click", async () => {
+  const out = document.getElementById("cache-status-results");
+  out.textContent = "checking cache...";
+  try {
+    const r = await chrome.runtime.sendMessage({ type: "cache-status" });
+    if (!r || !r.ok) {
+      out.innerHTML = `<span style="color:#faa;">error:</span> ${escapeHtml(r?.error || "no response")}`;
+      return;
+    }
+    rememberConfiguredScanRoots(r);
+    _cacheSkippedByRemote = new Map((r.remotes || []).map((m) => [m.remote, m.skipped_items || []]));
+    if (!r.cache_exists) {
+      const configured = (r.remotes || []).map((m) =>
+        `<div style="margin-top:6px;color:#ffa;">! ${escapeHtml(m.remote)} · never scanned</div>`
+      );
+      out.innerHTML = [
+        `<div><span style="color:#ffa;">cache not found</span></div>`,
+        `<div>${escapeHtml(r.cache_path || "")}</div>`,
+        ...configured,
+      ].join("");
+      return;
+    }
+    const rows = [
+      `<div><span style="color:#777;">Path:</span> ${escapeHtml(r.cache_path || "")}</div>`,
+      `<div><span style="color:#777;">Version:</span> ${escapeHtml(r.version ?? "?")}</div>`,
+      `<div><span style="color:#777;">Stale after:</span> ${escapeHtml(r.stale_hours ?? 24)}h</div>`,
+      `<div><span style="color:#777;">Configured target:</span> ${escapeHtml((r.configured?.default_target || []).join(", ") || "(none)")}</div>`,
+      `<div><span style="color:#777;">Configured source:</span> ${escapeHtml((r.configured?.default_source || []).join(", ") || "(none)")}</div>`,
+    ];
+    for (const m of r.remotes || []) {
+      const color = m.status === "never_scanned" || m.stale ? "#ffa" : "#afa";
+      const state = m.status === "never_scanned" ? "never scanned" : `${m.status || (m.stale ? "stale" : "fresh")} · age ${fmtCacheAge(m.age_hours)}`;
+      const skippedCount = Number(m.skipped_count) || 0;
+      const skippedNote = skippedCount
+        ? ` · <button class="chip-btn cache-show-skipped" type="button" data-remote="${escapeHtml(m.remote)}" style="color:#ffa;background:rgba(255,200,50,.08);border-color:rgba(255,200,50,.2);">${skippedCount} non-JAV ▾</button>`
+        : "";
+      rows.push(`<div style="margin-top:6px;"><span style="color:${color};">${escapeHtml(m.remote)}</span> · ${escapeHtml(state)} · ${escapeHtml(m.file_count)} files${skippedNote} <button class="chip-btn cache-refresh-remote" type="button" data-remote="${escapeHtml(m.remote)}">Refresh</button></div>`);
+      for (const issue of m.issues || []) {
+        rows.push(`<div style="color:#ffa;margin-left:12px;">! ${escapeHtml(issue.count)} ${escapeHtml(issue.message)}</div>`);
+      }
+    }
+    if ((r.warnings || []).length) {
+      rows.push(`<div style="margin-top:10px;color:#ffcc44;">Rebuild cache recommended:</div>`);
+      for (const w of r.warnings || []) {
+        rows.push(`<div style="color:#ffa;margin-left:12px;">! ${escapeHtml(w.message || w.code)}</div>`);
+      }
+    }
+    out.innerHTML = rows.join("");
+  } catch (err) {
+    out.innerHTML = `<span style="color:#faa;">error:</span> ${escapeHtml(err.message || String(err))}`;
+  }
+});
+
+// ---------- recent activity ----------
+
+function fmtActivityWhen(ts) {
+  if (!ts) return "?";
+  const s = Math.max(0, Math.round((Date.now() - ts) / 1000));
+  if (s < 60) return `${s}s ago`;
+  if (s < 3600) return `${Math.round(s / 60)}m ago`;
+  if (s < 86400) return `${Math.round(s / 3600)}h ago`;
+  return `${Math.round(s / 86400)}d ago`;
+}
+
+let recentActivityEntries = [];
+let activityFilter = "all";
+
+function activityOutcomeView(outcome) {
+  if (outcome === "hit") return { label: "Match", cls: "hit" };
+  if (outcome === "miss") return { label: "No Match", cls: "miss" };
+  if (outcome === "no_id") return { label: "No ID", cls: "no-id" };
+  if (outcome === "paused") return { label: "Paused", cls: "paused" };
+  return { label: outcome === "error" ? "Error" : (outcome || "Unknown"), cls: "error" };
+}
+
+function activityMatchesFilter(entry) {
+  if (activityFilter === "all") return true;
+  if (activityFilter === "other") return !["hit", "miss", "no_id"].includes(entry.outcome);
+  return entry.outcome === activityFilter;
+}
+
+function updateActivityFilterButtons() {
+  document.querySelectorAll("#activity-filters .activity-filter").forEach((btn) => {
+    btn.classList.toggle("active", btn.dataset.activityFilter === activityFilter);
+  });
+}
+
+function renderActivity(entries = recentActivityEntries) {
+  recentActivityEntries = entries || [];
+  const out = document.getElementById("activity-results");
+  if (!recentActivityEntries.length) {
+    out.innerHTML = `<span style="color:#777;">no recent activity yet</span>`;
+    return;
+  }
+  const visible = recentActivityEntries.filter(activityMatchesFilter).slice(0, 20);
+  if (!visible.length) {
+    out.innerHTML = `<span style="color:#777;">no recent activity for this filter</span>`;
+    return;
+  }
+  out.innerHTML = visible.map((e) => {
+    const outcome = activityOutcomeView(e.outcome);
+    const id = e.id || "no ID";
+    const mode = e.mode ? ` · ${e.mode}` : "";
+    const timing = Number.isFinite(e.total_ms) ? ` · ${e.total_ms}ms total` : "";
+    const page = e.title || e.url || e.reason || "";
+    const reason = e.reason && e.reason !== page ? `<div style="color:#888;margin-left:12px;">${escapeHtml(e.reason)}</div>` : "";
+    return `<div class="activity-entry">
+      <div class="activity-head">
+        <span class="activity-pill ${escapeHtml(outcome.cls)}">${escapeHtml(outcome.label)}</span>
+        <span>${escapeHtml(id)}</span>
+        <span class="activity-meta">${escapeHtml(e.trigger || "page")} · ${escapeHtml(fmtActivityWhen(e.ts))}${escapeHtml(mode)}${escapeHtml(timing)}</span>
+      </div>
+      <div style="color:#777;margin-left:12px;">${escapeHtml(page)}</div>
+      ${reason}
+    </div>`;
+  }).join("");
+}
+
+async function refreshActivity() {
+  const out = document.getElementById("activity-results");
+  out.textContent = "loading activity...";
+  try {
+    const r = await chrome.runtime.sendMessage({ type: "recent-activity" });
+    if (!r || !r.ok) {
+      out.innerHTML = `<span style="color:#faa;">error:</span> ${escapeHtml(r?.error || "no response")}`;
+      return;
+    }
+    renderActivity(r.entries || []);
+  } catch (err) {
+    out.innerHTML = `<span style="color:#faa;">error:</span> ${escapeHtml(err.message || String(err))}`;
+  }
+}
+
+document.getElementById("activity-refresh").addEventListener("click", refreshActivity);
+document.getElementById("activity-clear").addEventListener("click", async () => {
+  if (!confirm("Clear recent activity?")) return;
+  await chrome.runtime.sendMessage({ type: "clear-recent-activity" });
+  renderActivity([]);
+});
+document.getElementById("activity-filters").addEventListener("click", (e) => {
+  const btn = e.target.closest(".activity-filter");
+  if (!btn) return;
+  activityFilter = btn.dataset.activityFilter || "all";
+  updateActivityFilterButtons();
+  renderActivity();
+});
+updateActivityFilterButtons();
+
+// ---------- search test bench ----------
+
+function benchLookupRow(label, response) {
+  if (!response || !response.ok) {
+    const blocked = response?.paused ? "scanning paused" : response?.error || "no response";
+    return `<div class="diag-row fail"><span class="icon">x</span><span class="name">${escapeHtml(label)}</span><span class="detail">${escapeHtml(blocked)}</span></div>`;
+  }
+  const query = (response.queries || [])[0] || {};
+  const hitCount = Number(query.hits || response.hits || 0);
+  const status = hitCount ? "ok" : "warn";
+  const sample = (query.structured || response.structured || [])
+    .slice(0, 2)
+    .map((row) => row.full_path || row.path || row.jav_id)
+    .filter(Boolean)
+    .join(" | ");
+  const timing = response.timings?.host_rcjav_ms ?? response.timings?.native_ms ?? "?";
+  const detail = `${hitCount} hit(s) · ${timing}ms${sample ? ` · ${sample}` : ` · ${query.no_match_title || response.no_match_title || "No library hit"}`}`;
+  return `<div class="diag-row ${status}"><span class="icon">${hitCount ? "OK" : "!"}</span><span class="name">${escapeHtml(label)}</span><span class="detail">${escapeHtml(detail)}</span></div>`;
+}
+
+function benchLookupHits(response) {
+  if (!response || !response.ok) return null;
+  const query = (response.queries || [])[0] || {};
+  return Number(query.hits || response.hits || 0);
+}
+
+async function runSearchBench() {
+  const out = document.getElementById("search-bench-results");
+  const text = document.getElementById("search-bench-input").value.trim();
+  if (!text) {
+    out.innerHTML = `<span style="color:#ffa;">paste an ID or text that contains one</span>`;
+    return;
+  }
+  out.textContent = "extracting ID...";
+  try {
+    const extraction = await chrome.runtime.sendMessage({
+      type: "test-id-text",
+      text,
+      normalizers: readNormalizers(),
+    });
+    if (!extraction || !extraction.ok) {
+      out.innerHTML = `<span style="color:#faa;">extract failed:</span> ${escapeHtml(extraction?.error || "no response")}`;
+      return;
+    }
+    const extracted = extraction.extracted || {};
+    const extractionRows = [
+      `<div class="diag-row ${extracted.id ? "ok" : "warn"}"><span class="icon">${extracted.id ? "OK" : "!"}</span><span class="name">Extracted ID</span><span class="detail">${escapeHtml(extracted.id || "none")}</span></div>`,
+      `<div class="diag-row info"><span class="icon">i</span><span class="name">Rule</span><span class="detail">${escapeHtml(extracted.source || "none")}${extracted.pattern ? ` · ${escapeHtml(extracted.pattern)}` : ""}${extracted.replacement ? ` -> ${escapeHtml(extracted.replacement)}` : ""}</span></div>`,
+    ];
+    if (!extracted.id) {
+      out.innerHTML = extractionRows.join("") + `<div style="color:#777;margin-top:7px;">No lookup ran because the pasted sample did not extract an ID.</div>`;
+      return;
+    }
+    out.innerHTML = extractionRows.join("") + `<div style="color:#777;margin-top:7px;">Comparing LIVE and CACHE for ${escapeHtml(extracted.id)}...</div>`;
+    const [settings, live, cached] = await Promise.all([
+      chrome.runtime.sendMessage({ type: "get-settings" }),
+      chrome.runtime.sendMessage({ type: "bulk-query", queries: [extracted.id], quick: true }),
+      chrome.runtime.sendMessage({ type: "bulk-query", queries: [extracted.id], quick: false }),
+    ]);
+    const liveHits = benchLookupHits(live);
+    const cacheHits = benchLookupHits(cached);
+    const mismatch = liveHits != null && cacheHits != null && liveHits !== cacheHits;
+    const activeProfile = settings?.activeProfile || "config.json defaults";
+    out.innerHTML = [
+      ...extractionRows,
+      `<div class="diag-row info"><span class="icon">i</span><span class="name">Profile</span><span class="detail">${escapeHtml(activeProfile)}</span></div>`,
+      benchLookupRow("LIVE", live),
+      benchLookupRow("CACHE", cached),
+      mismatch
+        ? `<div class="diag-row warn"><span class="icon">!</span><span class="name">Mismatch</span><span class="detail">LIVE and CACHE returned different hit counts. Check cache coverage/freshness and rebuild after ID-rule or library changes.</span></div>`
+        : `<div class="diag-row ok"><span class="icon">OK</span><span class="name">Compare</span><span class="detail">LIVE and CACHE returned the same hit count.</span></div>`,
+      `<div style="color:#777;margin-top:7px;">Extraction uses the ID Rules currently shown on this page. Search lookups use saved host settings and the active profile.</div>`,
+    ].join("");
+  } catch (err) {
+    out.innerHTML = `<span style="color:#faa;">test failed:</span> ${escapeHtml(err.message || String(err))}`;
+  }
+}
+
+document.getElementById("search-bench-run").addEventListener("click", runSearchBench);
+document.getElementById("search-bench-clear").addEventListener("click", () => {
+  document.getElementById("search-bench-input").value = "";
+  document.getElementById("search-bench-results").innerHTML = "";
+});
+
+// ---------- bulk ID check ----------
+
+function readBulkIds() {
+  return [...new Set(document.getElementById("bulk-id-input").value
+    .split(/[\s,]+/)
+    .map((x) => x.trim())
+    .filter(Boolean))];
+}
+
+function renderBulkResults(r) {
+  const out = document.getElementById("bulk-id-results");
+  if (!r || !r.ok) {
+    out.innerHTML = `<span style="color:#faa;">error:</span> ${escapeHtml(r?.error || "no response")}`;
+    return;
+  }
+  const rows = [
+    `<div><span style="color:#777;">Mode:</span> ${escapeHtml(r.search_mode || "?")} · <span style="color:#777;">Queries:</span> ${escapeHtml(r.query_count || 0)} · <span style="color:#777;">Hits:</span> ${escapeHtml(r.hits || 0)} · <span style="color:#777;">Host:</span> ${escapeHtml(r.timings?.host_rcjav_ms ?? "?")}ms</div>`,
+  ];
+  for (const q of r.queries || []) {
+    const hit = q.hits > 0;
+    const sample = (q.structured || []).slice(0, 3).map((h) => h.full_path || h.path || h.jav_id).join(" | ");
+    rows.push(`<div style="margin-top:7px;">
+      <span style="color:${hit ? "#afa" : "#ffa"};font-weight:600;">${hit ? "HIT" : "MISS"}</span>
+      <span>${escapeHtml(q.query || "?")}</span> · ${escapeHtml(q.hits || 0)} hit(s)
+      ${sample ? `<div style="color:#777;margin-left:12px;">${escapeHtml(sample)}</div>` : `<div style="color:#777;margin-left:12px;">${escapeHtml(q.no_match_title || "No library hit")}</div>`}
+    </div>`);
+  }
+  out.innerHTML = rows.join("");
+}
+
+document.getElementById("bulk-id-run").addEventListener("click", async () => {
+  const out = document.getElementById("bulk-id-results");
+  const queries = readBulkIds();
+  if (!queries.length) {
+    out.innerHTML = `<span style="color:#ffa;">paste at least one ID</span>`;
+    return;
+  }
+  out.textContent = `checking ${queries.length} ID(s)...`;
+  const r = await chrome.runtime.sendMessage({
+    type: "bulk-query",
+    queries,
+    quick: document.getElementById("quickMode").checked,
+  });
+  renderBulkResults(r);
+});
+document.getElementById("bulk-id-clear").addEventListener("click", () => {
+  document.getElementById("bulk-id-input").value = "";
+  document.getElementById("bulk-id-results").innerHTML = "";
+});
+
+// ---------- duplicate review ----------
+
+let lastDupeReview = null;
+
+function dupePath(row) {
+  return row?.full_path || row?.path || row?.jav_id || "?";
+}
+
+function _groupFmtKey(keep, deletions) {
+  const all = [keep, ...deletions];
+  const exts = new Set(all.map(f => (f.path || f.full_path || "").split(".").pop().toLowerCase()).filter(e => e && e.length <= 4 && /^[a-z]+$/.test(e)));
+  if (exts.has("mkv") && exts.has("mp4") && !exts.has("wmv") && !exts.has("avi")) return "MKV/MP4";
+  if (exts.has("wmv") && exts.has("mp4") && !exts.has("mkv")) return "WMV/MP4";
+  if (exts.has("avi") && exts.has("mp4") && !exts.has("mkv")) return "AVI/MP4";
+  if (exts.size === 1) return "Same format";
+  return null; // mixed/unusual — visible under All, no chip
+}
+
+function _pathRes(path) {
+  if (/\[2160p\]/i.test(path) || /\b4[kK]\b/.test(path)) return 2160;
+  if (/\[1080p\]/i.test(path)) return 1080;
+  if (/\[720p\]/i.test(path)) return 720;
+  if (/\[480p\]/i.test(path)) return 480;
+  return 0;
+}
+
+function _groupResKey(keep, deletions) {
+  const keepRes = _pathRes(dupePath(keep));
+  const maxDelRes = deletions.reduce((m, d) => Math.max(m, _pathRes(dupePath(d))), 0);
+  if (keepRes === 0 && maxDelRes === 0) return "unknown";
+  if (keepRes === maxDelRes) return "same";
+  return keepRes > maxDelRes ? "upgrade" : "downgrade";
+}
+
+let _drActiveFmt = "all";
+let _drActiveRes = "all";
+let _drActiveStatus = "all";
+let _drActiveParts = "all";
+let _drActiveVip = "all";
+let _drActiveSearch = "";
+
+function _drPromoteToKeep(row) {
+  row.classList.remove("del", "confirmed", "unconfirmed", "queued");
+  row.classList.add("keep");
+  const tag = row.querySelector(".dr-tag");
+  tag.textContent = "KEEP";
+  tag.className = "dr-tag keep";
+}
+
+function _drDemoteToDelete(row) {
+  row.classList.remove("keep", "queued");
+  row.classList.add("del", "confirmed");
+  const tag = row.querySelector(".dr-tag");
+  tag.textContent = "DELETE?";
+  tag.className = "dr-tag del";
+}
+
+function _drApplyFilters() {
+  const wraps = document.querySelectorAll("#dupe-review-modal-body .dr-card-wrap");
+  for (const wrap of wraps) {
+    const fmtMatch = _drActiveFmt === "all" || wrap.dataset.fmt === _drActiveFmt;
+    const resMatch = _drActiveRes === "all" || wrap.dataset.res === _drActiveRes;
+    let statusMatch = true;
+    if (_drActiveStatus !== "all") {
+      const skipped = wrap.classList.contains("skipped");
+      const delRows = wrap.querySelectorAll(".dr-row.del");
+      const doneRows = wrap.querySelectorAll(".dr-row.del.done");
+      const allDone = delRows.length > 0 && doneRows.length === delRows.length;
+      if (_drActiveStatus === "skipped") statusMatch = skipped;
+      else if (_drActiveStatus === "done") statusMatch = !skipped && allDone;
+      else statusMatch = !skipped && !allDone; // pending
+    }
+    const partsMatch = _drActiveParts === "all" || wrap.dataset.parts === "1";
+    const vipMatch = _drActiveVip === "all" || wrap.dataset.vip === "1";
+    const q = _drActiveSearch;
+    const searchMatch = !q
+      || (wrap.querySelector(".dr-card-id")?.textContent.toLowerCase().includes(q))
+      || ([...wrap.querySelectorAll(".dr-path")].some(p => p.textContent.toLowerCase().includes(q)));
+    wrap.classList.toggle("dr-hidden", !(fmtMatch && resMatch && statusMatch && partsMatch && vipMatch && searchMatch));
+  }
+}
+
+function _drBadges(keep, deletions, catalogs) {
+  const all = [keep, ...deletions, ...catalogs];
+  const paths = all.map((f) => dupePath(f));
+  const out = [];
+  if (paths.some((p) => /\[2160p\]/i.test(p) || /\b4k\b/i.test(p))) {
+    out.push(`<span class="dr-badge b4k">4K</span>`);
+  } else if (paths.some((p) => /\[1080p\]/i.test(p))) {
+    out.push(`<span class="dr-badge b1080">1080p</span>`);
+  }
+  if (paths.some((p) => /clearjav/i.test(p))) {
+    out.push(`<span class="dr-badge bcljav">CLEARJAV</span>`);
+  }
+  const exts = new Set(
+    all.map((f) => (f.path || f.full_path || "").split(".").pop().toLowerCase()).filter((e) => e && e.length <= 4)
+  );
+  if (exts.size > 1) {
+    out.push(`<span class="dr-badge bfmt">${escapeHtml([...exts].join("/").toUpperCase())}</span>`);
+  } else if (exts.has("mkv")) {
+    out.push(`<span class="dr-badge bmkv">MKV</span>`);
+  }
+  return out.join("");
+}
+
+function renderDupeReview(r) {
+  const out = document.getElementById("dupe-review-modal-body");
+  const summary = document.getElementById("dupe-review-results");
+  const exportBtn = document.getElementById("dupe-review-export");
+  if (!r || !r.ok) {
+    lastDupeReview = null;
+    exportBtn.disabled = true;
+    out.innerHTML = `<div class="dr-empty"><span style="color:#f87171;">Error:</span> ${escapeHtml(r?.error || "no response")}</div>`;
+    summary.innerHTML = out.innerHTML;
+    openModal("dupe-review-modal");
+    return;
+  }
+  lastDupeReview = r;
+  exportBtn.disabled = false;
+  _drActiveFmt = "all";
+  _drActiveRes = "all";
+  _drActiveStatus = "all";
+  _drActiveParts = "all";
+  _drActiveVip = "all";
+  _drActiveSearch = "";
+
+  const groups = Object.entries(r.groups || {});
+  const totalCandidates = groups.reduce((n, [, g]) => n + (g.delete_candidates?.length || 0), 0);
+  const roots = [
+    ...(r.roots?.source || []).map((root) => `source: ${root}`),
+    ...(r.roots?.target || []).map((root) => `target: ${root}`),
+  ];
+
+  // Compute per-group fmt/res keys and counts for filter bar
+  const fmtCounts = {};
+  const resCounts = {};
+  let partsCount = 0;
+  let vipCount = 0;
+  let riskCount = 0;
+  for (const [javId, g] of groups) {
+    const fk = _groupFmtKey(g.keep || {}, g.delete_candidates || []);
+    const rk = _groupResKey(g.keep || {}, g.delete_candidates || []);
+    fmtCounts[fk] = (fmtCounts[fk] || 0) + 1;
+    resCounts[rk] = (resCounts[rk] || 0) + 1;
+    if (javId.includes("#part")) partsCount++;
+    if ([g.keep, ...(g.delete_candidates || [])].some((row) => /(?:^|[\\/])clearjav(?:[\\/]|$)/i.test(dupePath(row)))) vipCount++;
+    if ((g.risks || []).length) riskCount++;
+  }
+
+  const parts = [];
+
+  // Filter bar (sticky top)
+  if (groups.length) {
+    const fmtOrder = ["MKV/MP4", "WMV/MP4", "AVI/MP4", "Same format"];
+    const resOrder = [
+      { key: "same", label: "Same res" },
+      { key: "upgrade", label: "Upgrade" },
+    ];
+    const fmtChips = fmtOrder
+      .filter(k => fmtCounts[k])
+      .map(k => `<button class="dr-chip" data-ftype="fmt" data-fval="${escapeHtml(k)}">${escapeHtml(k)} (${fmtCounts[k]})</button>`)
+      .join("");
+    const resChips = resOrder
+      .filter(({ key }) => resCounts[key])
+      .map(({ key, label }) => `<button class="dr-chip" data-ftype="res" data-fval="${key}">${escapeHtml(label)} (${resCounts[key]})</button>`)
+      .join("");
+    const totalGroups = groups.length;
+    parts.push(`<div class="dr-filter-bar">
+      <input id="dr-search" class="dr-search" type="text" placeholder="Search ID or path…" autocomplete="off" spellcheck="false">
+      <span class="dr-filter-sep"></span>
+      <span class="dr-filter-label">Format:</span>
+      <button class="dr-chip active" data-ftype="fmt" data-fval="all">All</button>
+      ${fmtChips}
+      ${resChips.length ? `<span class="dr-filter-sep"></span><span class="dr-filter-label">Resolution:</span><button class="dr-chip active" data-ftype="res" data-fval="all">All</button>${resChips}` : ""}
+      <span class="dr-filter-sep"></span>
+      <span class="dr-filter-label">Status:</span>
+      <button class="dr-chip active" data-ftype="status" data-fval="all">All</button>
+      <button class="dr-chip" data-ftype="status" data-fval="pending">Pending (${totalGroups - riskCount})</button>
+      <button class="dr-chip" data-ftype="status" data-fval="done">Done (0)</button>
+      <button class="dr-chip" data-ftype="status" data-fval="skipped">Skipped (${riskCount})</button>
+      ${vipCount ? `<span class="dr-filter-sep"></span><button class="dr-chip active" data-ftype="vip" data-fval="all">All</button><button class="dr-chip" data-ftype="vip" data-fval="only">ClearJAV (${vipCount})</button>` : ""}
+      ${partsCount ? `<span class="dr-filter-sep"></span><button class="dr-chip active" data-ftype="parts" data-fval="all">All</button><button class="dr-chip" data-ftype="parts" data-fval="only">Parts (${partsCount})</button>` : ""}
+    </div>`);
+  }
+
+  // Stats bar
+  parts.push(`<div class="dr-stats">
+    <div class="dr-stat"><div class="val red">${escapeHtml(r.potential_reclaim_human || "0 B")}</div><div class="key">Recoverable</div></div>
+    <div class="dr-stat"><div class="val">${escapeHtml(String(r.group_count || 0))}</div><div class="key">Duplicate Groups</div></div>
+    <div class="dr-stat"><div class="val blue">${escapeHtml(String(totalCandidates))}</div><div class="key">Delete Candidates</div></div>
+  </div>`);
+  if (riskCount) {
+    parts.push(`<div class="dr-roots" style="color:#ffe487;">${escapeHtml(String(riskCount))} risky group${riskCount !== 1 ? "s" : ""} are skipped by default. Review part-like filenames before adding them back to the delete queue.</div>`);
+  }
+
+  // Roots hint
+  if (roots.length) {
+    parts.push(`<div class="dr-roots">${escapeHtml(roots.join("  ·  "))}</div>`);
+  }
+
+  // Group cards
+  if (!groups.length) {
+    parts.push(`<div class="dr-empty">No cached duplicate groups found.</div>`);
+  } else {
+    const cards = [];
+    for (const [javId, group] of groups) {
+      const keep = group.keep || {};
+      const deletions = group.delete_candidates || [];
+      const catalogs = group.catalog || [];
+      const reclaim = deletions.reduce((s, e) => s + (e.size || 0), 0);
+      const reclaimHuman = deletions.length && deletions[0].size_human
+        ? deletions.map((d) => d.size_human).join(" + ")
+        : "";
+      const reclaimLabel = reclaimHuman
+        ? `<span class="dr-card-reclaim">−${escapeHtml(reclaimHuman)}</span>`
+        : "";
+
+      const fmtKey = _groupFmtKey(keep, deletions);
+      const resKey = _groupResKey(keep, deletions);
+      const risks = group.risks || [];
+      const keepReason = group.keep_reason?.summary || "";
+
+      const rows = [];
+      if (risks.length) {
+        rows.push(`<div class="dr-risk-note"><strong>Review before deleting:</strong> ${risks.map((risk) => escapeHtml(risk.summary || "multipart risk")).join("<br>")}</div>`);
+      }
+      rows.push(`<div class="dr-row keep" data-full-path="${escapeHtml(dupePath(keep))}">
+        <span class="dr-tag keep">KEEP</span>
+        <span class="dr-path" title="${escapeHtml(dupePath(keep))}">${escapeHtml(dupePath(keep))}</span>
+        ${keep.size_human ? `<span class="dr-sz keep">${escapeHtml(keep.size_human)}</span>` : ""}
+      </div>`);
+      if (keepReason) {
+        rows.push(`<div class="dr-keep-reason">Suggested KEEP reason: ${escapeHtml(keepReason)}</div>`);
+      }
+      for (const d of deletions) {
+        rows.push(`<div class="dr-row del confirmed" data-full-path="${escapeHtml(dupePath(d))}">
+          <span class="dr-tag del">DELETE?</span>
+          <span class="dr-path" title="${escapeHtml(dupePath(d))}">${escapeHtml(dupePath(d))}</span>
+          ${d.size_human ? `<span class="dr-sz del">${escapeHtml(d.size_human)}</span>` : ""}
+        </div>`);
+      }
+      for (const c of catalogs) {
+        rows.push(`<div class="dr-row cat">
+          <span class="dr-tag cat">CATALOG</span>
+          <span class="dr-path" title="${escapeHtml(dupePath(c))}">${escapeHtml(dupePath(c))}</span>
+          ${c.size_human ? `<span class="dr-sz cat">${escapeHtml(c.size_human)}</span>` : ""}
+        </div>`);
+      }
+
+      const hasClearJav = [keep, ...deletions].some((row) => /(?:^|[\\/])clearjav(?:[\\/]|$)/i.test(dupePath(row)));
+      cards.push(`<div class="dr-card-wrap${risks.length ? " skipped dr-risk" : ""}" data-fmt="${escapeHtml(fmtKey)}" data-res="${escapeHtml(resKey)}" data-parts="${javId.includes("#part") ? "1" : "0"}" data-vip="${hasClearJav ? "1" : "0"}" data-risk="${risks.length ? "1" : "0"}">
+        <div class="dr-card">
+          <div class="dr-card-head">
+            <span class="dr-card-id">${escapeHtml(javId)}</span>
+            ${_drBadges(keep, deletions, catalogs)}
+            ${reclaimLabel}
+          </div>
+          <div class="dr-card-body">${rows.join("")}</div>
+        </div>
+        <button class="dr-skip-ear" title="${risks.length ? "Risk flagged - click to include after review" : "Skip - decide later"}"><span>${risks.length ? "Review" : "Skip"}</span></button>
+      </div>`);
+    }
+    parts.push(`<div class="dr-body">${cards.join("")}</div>`);
+  }
+
+
+  // Variant alerts — bare ID + variant coexist (e.g. IBW-902 and IBW-902z both present)
+  const variantAlerts = r.variant_alerts || [];
+  if (variantAlerts.length) {
+    const alertCards = variantAlerts.map((alert) => {
+      const rows = (alert.files || []).map((f) => {
+        const detectedId = f.detected_id || f.jav_id || "";
+        const isVariant = detectedId !== alert.bare_id;
+        const tag = isVariant
+          ? `<span class="dr-tag variant">${escapeHtml(detectedId)}</span>`
+          : `<span class="dr-tag bare">BARE</span>`;
+        return `<div class="dr-row variant">
+          ${tag}
+          <span class="dr-path" title="${escapeHtml(dupePath(f))}">${escapeHtml(dupePath(f))}</span>
+          ${f.size_human ? `<span class="dr-sz">${escapeHtml(f.size_human)}</span>` : ""}
+        </div>`;
+      }).join("");
+      return `<div class="dr-card variant-alert">
+        <div class="dr-card-head">
+          <span class="dr-card-id">${escapeHtml(alert.bare_id)}</span>
+          <span class="dr-variant-label">⚠ variant — manual review</span>
+        </div>
+        <div class="dr-card-body">${rows}</div>
+      </div>`;
+    }).join("");
+    parts.push(`<div class="dr-variant-section">
+      <div class="dr-variant-heading">⚠ ${variantAlerts.length} Variant Alert${variantAlerts.length !== 1 ? "s" : ""} — Same base ID, different product designator</div>
+      <div class="dr-body">${alertCards}</div>
+    </div>`);
+  }
+
+  if ((r.skipped || []).length) {
+    const samples = (r.skipped || []).slice(0, 5)
+      .map((s) => `<div class="dr-skipped-item">${escapeHtml(s.name || s.path || "?")} · ${escapeHtml(s.reason || "unparsed ID")}</div>`)
+      .join("");
+    parts.push(`<div class="dr-skipped">Skipped ${escapeHtml(String(r.skipped.length))} path(s) with no parseable ID${samples ? ":" : "."}</div>${samples}`);
+  }
+
+  out.innerHTML = parts.join("");
+  summary.textContent = `${r.group_count || 0} cached duplicate group(s) reviewed. Results are open in the review window.`;
+  openModal("dupe-review-modal");
+}
+
+function _drUpdateExecuteBtn() {
+  const confirmed = document.querySelectorAll("#dupe-review-modal-body .dr-card-wrap:not(.skipped):not(.dr-hidden) .dr-row.del.confirmed:not(.done)");
+  const btn = document.getElementById("dupe-review-execute");
+  const status = document.getElementById("dupe-review-confirm-status");
+  const n = confirmed.length;
+  btn.textContent = `Execute Deletions (${n})`;
+  btn.disabled = n === 0;
+  status.textContent = n > 0 ? `${n} file${n !== 1 ? "s" : ""} queued for deletion — click to execute` : "";
+}
+
+// Search input
+document.getElementById("dupe-review-modal-body").addEventListener("input", (e) => {
+  if (e.target.id !== "dr-search") return;
+  _drActiveSearch = e.target.value.trim().toLowerCase();
+  _drApplyFilters();
+  _drUpdateExecuteBtn();
+});
+
+// Filter chips + toggle DELETE? rows on click
+document.getElementById("dupe-review-modal-body").addEventListener("click", (e) => {
+  // Filter chip
+  const chip = e.target.closest(".dr-chip");
+  if (chip) {
+    const ftype = chip.dataset.ftype;
+    const fval = chip.dataset.fval;
+    if (ftype === "fmt") {
+      _drActiveFmt = fval;
+    } else if (ftype === "res") {
+      _drActiveRes = fval;
+    } else if (ftype === "status") {
+      _drActiveStatus = fval;
+    } else if (ftype === "parts") {
+      _drActiveParts = fval;
+    } else if (ftype === "vip") {
+      _drActiveVip = fval;
+    }
+    document.querySelectorAll(`#dupe-review-modal-body .dr-chip[data-ftype='${ftype}']`).forEach(c => {
+      c.classList.toggle("active", c.dataset.fval === fval);
+    });
+    _drApplyFilters();
+    _drUpdateExecuteBtn();
+    return;
+  }
+
+  // Search input
+  if (e.target.id === "dr-search") return; // handled via input event below
+
+  // Skip ear — toggle skipped on the wrap
+  const ear = e.target.closest(".dr-skip-ear");
+  if (ear) {
+    ear.closest(".dr-card-wrap").classList.toggle("skipped");
+    _drUpdateExecuteBtn();
+    return;
+  }
+
+  // Click KEEP row → full swap: this becomes DELETE?, pick a replacement KEEP
+  const keepRow = e.target.closest(".dr-row.keep");
+  if (keepRow && !keepRow.classList.contains("done")) {
+    const card = keepRow.closest(".dr-card");
+    // Prefer an unconfirmed del row as new KEEP (least disruptive), else first any del row
+    const newKeep = card.querySelector(".dr-row.del.unconfirmed:not(.done)")
+                 || card.querySelector(".dr-row.del:not(.done)");
+    if (!newKeep) return;
+    _drPromoteToKeep(newKeep);
+    _drDemoteToDelete(keepRow);
+    _drUpdateExecuteBtn();
+    return;
+  }
+
+  // DELETE? rows are not clickable — click the KEEP row to swap
+});
+
+document.getElementById("dupe-review-execute").addEventListener("click", async () => {
+  const rows = [...document.querySelectorAll("#dupe-review-modal-body .dr-card-wrap:not(.skipped):not(.dr-hidden) .dr-row.del.confirmed:not(.done)")];
+  if (!rows.length) return;
+  const deleteRows = rows.filter((row) => row.dataset.fullPath);
+  if (!deleteRows.length) return;
+  const btn = document.getElementById("dupe-review-execute");
+  const status = document.getElementById("dupe-review-confirm-status");
+  const total = deleteRows.length;
+  btn.disabled = true;
+  let done = 0, failed = 0;
+  for (const [index, row] of deleteRows.entries()) {
+    const path = row.dataset.fullPath;
+    status.textContent = `Deleting ${index + 1}/${total}...`;
+    const res = await chrome.runtime.sendMessage({ type: "delete_batch", paths: [path] });
+    if (!res?.ok && res?.error === "deletion is disabled in options") {
+      status.textContent = "Deletion is disabled - enable it in the Deletion tab first.";
+      btn.disabled = false;
+      return;
+    }
+    const r = (res?.results || [])[0] || { ok: false, error: res?.error || "delete failed" };
+    const tag = row.querySelector(".dr-tag");
+    if (r.ok) {
+      row.classList.remove("confirmed");
+      row.classList.add("done");
+      tag.textContent = "DELETED";
+      done++;
+    } else {
+      row.classList.add("error");
+      tag.textContent = "ERROR";
+      row.title = r.error || "delete failed";
+      failed++;
+    }
+  }
+
+  const parts = [];
+  if (done) parts.push(`${done} deleted`);
+  if (failed) parts.push(`${failed} failed`);
+  status.textContent = parts.join(" · ") || "Nothing processed.";
+  _drUpdateExecuteBtn();
+});
+
+document.getElementById("dupe-review-run").addEventListener("click", async () => {
+  const out = document.getElementById("dupe-review-modal-body");
+  const executeBtn = document.getElementById("dupe-review-execute");
+  out.textContent = "reviewing cached duplicate groups...";
+  executeBtn.disabled = true;
+  executeBtn.textContent = "Execute Deletions (0)";
+  document.getElementById("dupe-review-confirm-status").textContent = "";
+  openModal("dupe-review-modal");
+  renderDupeReview(await chrome.runtime.sendMessage({ type: "dupe-review" }));
+  _drUpdateExecuteBtn();
+});
+
+document.getElementById("dupe-review-export").addEventListener("click", () => {
+  if (!lastDupeReview) return;
+  const blob = new Blob([JSON.stringify(lastDupeReview, null, 2)], { type: "application/json" });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  a.href = url;
+  a.download = `rclone-jav-dupe-review-${stamp}.json`;
+  a.click();
+  setTimeout(() => URL.revokeObjectURL(url), 0);
+});
+for (const id of ["dupe-review-modal-close", "dupe-review-modal-done"]) {
+  document.getElementById(id).addEventListener("click", () => closeModal("dupe-review-modal"));
+}
+document.getElementById("dupe-review-modal").addEventListener("click", (event) => {
+  if (event.target.id === "dupe-review-modal") closeModal("dupe-review-modal");
+});
+
+// ---- Keep Ranking ----
+
+const KR_DEFAULT_FMTS = ["mkv", "mp4", "wmv", "avi"];
+const KR_DEFAULT_VIP_FOLDERS = ["ClearJAV"];
+
+function _krWireDraggableList(list) {
+  if (!list) return;
+  let dragSrc = null;
+  for (const item of list.querySelectorAll(".kr-fmt-item")) {
+    item.addEventListener("dragstart", (e) => {
+      dragSrc = item;
+      item.classList.add("dragging");
+      e.dataTransfer.effectAllowed = "move";
+    });
+    item.addEventListener("dragend", () => {
+      item.classList.remove("dragging");
+      list.querySelectorAll(".kr-fmt-item").forEach(i => i.classList.remove("drag-over"));
+      list.querySelectorAll(".kr-fmt-item").forEach((el, idx) => {
+        const pr = el.querySelector(".kr-fmt-priority");
+        if (pr) pr.textContent = `#${idx + 1}`;
+      });
+    });
+    item.addEventListener("dragover", (e) => {
+      e.preventDefault();
+      e.dataTransfer.dropEffect = "move";
+      if (item !== dragSrc) item.classList.add("drag-over");
+    });
+    item.addEventListener("dragleave", () => item.classList.remove("drag-over"));
+    item.addEventListener("drop", (e) => {
+      e.preventDefault();
+      item.classList.remove("drag-over");
+      if (dragSrc && dragSrc !== item) {
+        const items = [...list.querySelectorAll(".kr-fmt-item")];
+        const srcIdx = items.indexOf(dragSrc);
+        const dstIdx = items.indexOf(item);
+        if (srcIdx < dstIdx) list.insertBefore(dragSrc, item.nextSibling);
+        else list.insertBefore(dragSrc, item);
+      }
+    });
+  }
+}
+
+function _krRenderFmtList(fmts) {
+  const list = document.getElementById("kr-fmt-list");
+  if (!list) return;
+  list.innerHTML = fmts.map((fmt, i) =>
+    `<div class="kr-fmt-item" draggable="true" data-fmt="${escapeHtml(fmt)}">
+      <span class="kr-fmt-grip">⠿</span>
+      <span>${escapeHtml(fmt)}</span>
+      <span class="kr-fmt-priority">#${i + 1}</span>
+    </div>`
+  ).join("");
+  _krWireDraggableList(list);
+}
+
+function _krGetCurrentFmts() {
+  return [...document.querySelectorAll("#kr-fmt-list .kr-fmt-item")]
+    .map(el => el.dataset.fmt);
+}
+
+function _krRenderVipList(folders) {
+  const list = document.getElementById("kr-vip-list");
+  if (!list) return;
+  list.innerHTML = (folders || []).map((folder, i) =>
+    `<div class="kr-fmt-item" draggable="true" data-folder="${escapeHtml(folder)}">
+      <span class="kr-fmt-grip">⠿</span>
+      <span>${escapeHtml(folder)}</span>
+      <button class="kr-vip-remove" type="button" title="Remove VIP folder">x</button>
+      <span class="kr-fmt-priority">#${i + 1}</span>
+    </div>`
+  ).join("");
+  for (const btn of list.querySelectorAll(".kr-vip-remove")) {
+    btn.addEventListener("click", () => {
+      btn.closest(".kr-fmt-item")?.remove();
+      list.querySelectorAll(".kr-fmt-item").forEach((el, idx) => {
+        const pr = el.querySelector(".kr-fmt-priority");
+        if (pr) pr.textContent = `#${idx + 1}`;
+      });
+    });
+  }
+  _krWireDraggableList(list);
+}
+
+function _krGetVipFolders() {
+  return [...document.querySelectorAll("#kr-vip-list .kr-fmt-item")]
+    .map((el) => el.dataset.folder)
+    .filter(Boolean);
+}
+
+function _krAddVipFolder() {
+  const input = document.getElementById("kr-vip-add");
+  const folder = input?.value.trim();
+  if (!folder) return;
+  const current = _krGetVipFolders();
+  if (!current.some((item) => item.toLowerCase() === folder.toLowerCase())) {
+    _krRenderVipList([...current, folder]);
+  }
+  input.value = "";
+}
+
+document.getElementById("kr-vip-add-btn")?.addEventListener("click", _krAddVipFolder);
+document.getElementById("kr-vip-add")?.addEventListener("keydown", (event) => {
+  if (event.key === "Enter") {
+    event.preventDefault();
+    _krAddVipFolder();
+  }
+});
+
+async function loadKeepRanking() {
+  try {
+    const r = await chrome.runtime.sendMessage({ type: "get-keep-ranking" });
+    if (!r || !r.ok) return;
+    const ranking = r.keep_ranking || {};
+    const toleranceEl = document.getElementById("kr-tolerance");
+    const resTagEl = document.getElementById("kr-res-tag");
+    const longerNameEl = document.getElementById("kr-longer-name");
+    if (toleranceEl) toleranceEl.value = ranking.size_tolerance_mib ?? 0;
+    if (resTagEl) resTagEl.checked = ranking.tiebreak_res_tag !== false;
+    if (longerNameEl) longerNameEl.checked = ranking.tiebreak_longer_name !== false;
+    _krRenderVipList(ranking.priority_folders || KR_DEFAULT_VIP_FOLDERS);
+    _krRenderFmtList(ranking.format_preference || KR_DEFAULT_FMTS);
+  } catch (e) {
+    // non-fatal — panel just shows defaults
+    _krRenderVipList(KR_DEFAULT_VIP_FOLDERS);
+    _krRenderFmtList(KR_DEFAULT_FMTS);
+  }
+}
+
+document.getElementById("kr-save")?.addEventListener("click", async () => {
+  const status = document.getElementById("kr-save-status");
+  const toleranceEl = document.getElementById("kr-tolerance");
+  const resTagEl = document.getElementById("kr-res-tag");
+  const longerNameEl = document.getElementById("kr-longer-name");
+  const tolerance = parseFloat(toleranceEl?.value ?? "0");
+  if (isNaN(tolerance) || tolerance < 0) {
+    status.textContent = "Size tolerance must be 0 or a positive number.";
+    status.className = "kr-save-status err";
+    return;
+  }
+  const ranking = {
+    priority_folders: _krGetVipFolders(),
+    size_tolerance_mib: tolerance,
+    format_preference: _krGetCurrentFmts(),
+    tiebreak_res_tag: resTagEl?.checked !== false,
+    tiebreak_longer_name: longerNameEl?.checked !== false,
+  };
+  status.textContent = "Saving…";
+  status.className = "kr-save-status";
+  try {
+    const r = await chrome.runtime.sendMessage({ type: "save-keep-ranking", keep_ranking: ranking });
+    if (r?.ok) {
+      status.textContent = "Saved — next dupe review will use the updated ranking.";
+      status.className = "kr-save-status ok";
+    } else {
+      status.textContent = "Error: " + (r?.error || "unknown");
+      status.className = "kr-save-status err";
+    }
+  } catch (e) {
+    status.textContent = "Error: " + e.message;
+    status.className = "kr-save-status err";
+  }
+});
+
+// Load on page open
+loadKeepRanking();
+
+// ---- Library Issues ----
+
+let lastLibraryIssues = null;
+let _libraryIssuesDirty = false;
+
+function renderLibraryIssues(r) {
+  const out = document.getElementById("library-issues-modal-body");
+  const statusEl = document.getElementById("library-issues-results");
+  const renameAllBtn = document.getElementById("library-issues-rename-all");
+  const renameStatus = document.getElementById("library-issues-rename-status");
+
+  if (!r || !r.ok) {
+    lastLibraryIssues = null;
+    renameAllBtn.disabled = true;
+    out.innerHTML = `<div class="li-empty" style="color:#f87171;">Error: ${escapeHtml(r?.error || "no response")}</div>`;
+    openModal("library-issues-modal");
+    return;
+  }
+  lastLibraryIssues = r;
+
+  const brackets = r.bracket_names || [];
+  const nohyphens = r.nohyphen_names || [];
+  const total = brackets.length + nohyphens.length;
+
+  renameAllBtn.disabled = total === 0;
+  renameStatus.textContent = "";
+
+  const parts = [];
+  if (!total) {
+    parts.push(`<div class="li-empty">✓ No library issues found. All filenames are canonical.</div>`);
+  } else {
+    parts.push(`<div class="li-stats"><b>${total}</b> file${total !== 1 ? "s" : ""} with non-canonical names — <b>${brackets.length}</b> bracket-wrapped, <b>${nohyphens.length}</b> no-hyphen</div>`);
+
+    const makeRow = (entry, tagClass, tagLabel) => {
+      const fname = entry.path.split("/").pop();
+      const dir = entry.path.lastIndexOf("/") !== -1 ? entry.path.slice(0, entry.path.lastIndexOf("/") + 1) : "";
+      return `<div class="li-row" data-remote="${escapeHtml(entry.remote)}" data-old="${escapeHtml(entry.path)}" data-new="${escapeHtml(dir + entry.canonical_name)}">
+        <span class="li-tag ${tagClass}">${tagLabel}</span>
+        <div class="li-names">
+          <span class="li-old" title="${escapeHtml(entry.path)}">${escapeHtml(fname)}</span>
+          <span class="li-new" title="${escapeHtml(entry.canonical_name)}">→ ${escapeHtml(entry.canonical_name)}</span>
+        </div>
+        <span class="li-sz">${escapeHtml(entry.size_human || "")}</span>
+        <button class="li-rename-btn" type="button">Rename</button>
+      </div>`;
+    };
+
+    if (brackets.length) {
+      parts.push(`<div class="li-section-head">Bracket-wrapped IDs (${brackets.length})</div>`);
+      parts.push(brackets.map((e) => makeRow(e, "bracket", "[ ]")).join(""));
+    }
+    if (nohyphens.length) {
+      parts.push(`<div class="li-section-head">No-hyphen IDs (${nohyphens.length})</div>`);
+      parts.push(nohyphens.map((e) => makeRow(e, "nohyphen", "no hyphen")).join(""));
+    }
+  }
+
+  out.innerHTML = parts.join("");
+  statusEl.textContent = total
+    ? `${total} library issue(s) found. Review window is open.`
+    : "No library issues found.";
+  openModal("library-issues-modal");
+
+  // Per-row rename buttons
+  out.querySelectorAll(".li-rename-btn").forEach((btn) => {
+    btn.addEventListener("click", async () => {
+      const row = btn.closest(".li-row");
+      const remote = row.dataset.remote;
+      const oldPath = row.dataset.old;
+      const newPath = row.dataset.new;
+      btn.disabled = true;
+      btn.textContent = "…";
+      const res = await chrome.runtime.sendMessage({
+        type: "rename_file", remote, old_path: oldPath, new_path: newPath,
+      });
+      const tag = row.querySelector(".li-tag");
+      if (res?.ok) {
+        tag.className = "li-tag done";
+        tag.textContent = "✓";
+        btn.textContent = "Done";
+        row.querySelector(".li-old").style.textDecoration = "line-through";
+        _libraryIssuesDirty = true;
+      } else if (res?.conflict) {
+        tag.className = "li-tag conflict";
+        tag.textContent = "conflict";
+        btn.textContent = "Skip";
+        renameStatus.textContent = `Conflict: ${res.error || "target exists"}`;
+      } else {
+        tag.className = "li-tag conflict";
+        tag.textContent = "error";
+        btn.textContent = "Error";
+        renameStatus.textContent = res?.error || "rename failed";
+      }
+    });
+  });
+}
+
+document.getElementById("library-issues-run").addEventListener("click", async () => {
+  const out = document.getElementById("library-issues-modal-body");
+  out.innerHTML = `<div class="li-stats">Loading library issues from cache…</div>`;
+  openModal("library-issues-modal");
+  renderLibraryIssues(await chrome.runtime.sendMessage({ type: "library_issues" }));
+});
+
+document.getElementById("library-issues-rename-all").addEventListener("click", async () => {
+  const rows = [...document.querySelectorAll("#library-issues-modal-body .li-row")];
+  const renameStatus = document.getElementById("library-issues-rename-status");
+  const renameAllBtn = document.getElementById("library-issues-rename-all");
+
+  // Collect pending renames (skip already-done or disabled rows)
+  const pending = rows.reduce((acc, row) => {
+    const btn = row.querySelector(".li-rename-btn");
+    if (!btn || btn.disabled) return acc;
+    acc.push({ row, remote: row.dataset.remote, old_path: row.dataset.old, new_path: row.dataset.new });
+    return acc;
+  }, []);
+
+  if (!pending.length) return;
+
+  renameAllBtn.disabled = true;
+  renameStatus.textContent = `Renaming ${pending.length} file(s)…`;
+
+  const renames = pending.map(({ remote, old_path, new_path }) => ({ remote, old_path, new_path }));
+  const res = await chrome.runtime.sendMessage({ type: "rename_files_batch", renames });
+
+  const results = res?.results || [];
+  let done = 0, conflicts = 0, errors = 0;
+
+  results.forEach((r, i) => {
+    const { row } = pending[i];
+    const tag = row.querySelector(".li-tag");
+    const btn = row.querySelector(".li-rename-btn");
+    if (r.ok) {
+      tag.className = "li-tag done"; tag.textContent = "✓";
+      btn.disabled = true; btn.textContent = "Done";
+      row.querySelector(".li-old").style.textDecoration = "line-through";
+      done++;
+    } else if (r.conflict) {
+      tag.className = "li-tag conflict"; tag.textContent = "conflict";
+      btn.disabled = false; btn.textContent = "Skip";
+      conflicts++;
+    } else {
+      tag.className = "li-tag conflict"; tag.textContent = "error";
+      btn.disabled = false; btn.textContent = "Error";
+      errors++;
+    }
+  });
+
+  const parts = [];
+  if (done) parts.push(`${done} renamed`);
+  if (conflicts) parts.push(`${conflicts} conflict(s)`);
+  if (errors) parts.push(`${errors} error(s)`);
+  renameStatus.textContent = parts.join(" · ") || "Nothing to rename.";
+  renameAllBtn.disabled = false;
+  _libraryIssuesDirty = done > 0;
+});
+
+function _closeLibraryIssues() {
+  closeModal("library-issues-modal");
+  if (_libraryIssuesDirty) {
+    _libraryIssuesDirty = false;
+    chrome.runtime.sendMessage({ type: "library_issues" }, (r) => {
+      if (!r || !r.ok) return;
+      const total = (r.bracket_names?.length || 0) + (r.nohyphen_names?.length || 0);
+      document.getElementById("library-issues-results").textContent = total
+        ? `${total} library issue(s) found. Review window is open.`
+        : "No library issues found.";
+    });
+  }
+}
+for (const id of ["library-issues-modal-close", "library-issues-modal-done"]) {
+  document.getElementById(id).addEventListener("click", _closeLibraryIssues);
+}
+document.getElementById("library-issues-modal").addEventListener("click", (e) => {
+  if (e.target.id === "library-issues-modal") _closeLibraryIssues();
+});
+
+(function () {
+  const rebuildBtn = document.getElementById("cache-rebuild-run");
+  const rebuildMode = document.getElementById("cache-rebuild-mode");
+  const cacheStatusOut = document.getElementById("cache-status-results");
+  const scanJobOut = document.getElementById("scan-job-results");
+  let _optScanTimer = null;
+  let _optScanning = false;
+
+  const _stopOptPoll = () => { if (_optScanTimer) { clearInterval(_optScanTimer); _optScanTimer = null; } };
+
+  function _setOptScanningState(scanning) {
+    _optScanning = scanning;
+    rebuildBtn.textContent = scanning ? "✕ Cancel" : "Rebuild Cache";
+    if (rebuildMode) rebuildMode.disabled = scanning;
+    rebuildBtn.style.background = scanning ? "#3a1a1a" : "";
+    rebuildBtn.style.borderColor = scanning ? "#722" : "";
+    rebuildBtn.style.color = scanning ? "#faa" : "";
+  }
+
+  function _scanStatus(r) {
+    if (!r || r.no_state) return "idle";
+    if (r.scanning && !r.done) return "running";
+    if (r.cancelled) return "cancelled";
+    if (r.scan_ok === false) return "failed";
+    if (r.done) return "completed";
+    return "idle";
+  }
+
+  function _renderScanJob(r) {
+    if (!r || r.no_state) {
+      scanJobOut.innerHTML = `<span style="color:#777;">no scan job recorded yet</span>`;
+      return;
+    }
+    const status = _scanStatus(r);
+    const pillCls = status === "completed" ? "ok" : status === "failed" ? "fail" : "";
+    const jobLabel = status === "running" ? "Current Scan Job" : "Last Scan Job";
+    const mode = r.scan_since ? `incremental ${r.scan_since}` : "full";
+    const scope = (r.scope && r.scope.length) ? r.scope.join(", ") : "configured scan roots";
+    const finished = r.finished_at || r.started_at || "";
+    const when = finished ? new Date(finished).toLocaleString() : "";
+    const elapsed = r.elapsed_s != null ? `${Number(r.elapsed_s).toFixed(1)}s` : "";
+    const count = r.file_count != null ? `${Number(r.file_count).toLocaleString()} files` : "";
+    const summary = [mode, scope, count, elapsed].filter(Boolean).join(" · ");
+    const jobs = (r.remote_jobs && r.remote_jobs.length)
+      ? r.remote_jobs
+      : (r.remotes || []).map((remote, i) => ({
+          remote,
+          status: remote === r.current_remote ? status : i < (r.current_index || 0) ? "completed" : "queued",
+          files: remote === r.current_remote ? r.files_this_remote : null,
+          total: remote === r.current_remote ? r.files_remote_total : null,
+        }));
+    const jobRoots = jobs.map((j) => j.remote).filter(Boolean);
+    const retiredRoots = _configuredScanRoots.length
+      ? jobRoots.filter((root) => !_configuredScanRoots.includes(root))
+      : [];
+    const jobRows = jobs.map((j) => {
+      const files = Number.isFinite(j.files) ? Number(j.files).toLocaleString() : "?";
+      const total = Number.isFinite(j.total) ? Number(j.total).toLocaleString() : "";
+      const pct = Number.isFinite(j.files) && Number.isFinite(j.total) && j.total > 0
+        ? Math.min(100, Math.round((j.files / j.total) * 100)) : null;
+      const detail = [
+        j.label,
+        j.incremental ? "incremental" : "",
+        `${files}${total ? ` / ${total}` : ""} files`,
+        Number.isFinite(j.skipped) && j.skipped ? `${j.skipped} skipped` : "",
+      ].filter(Boolean).join(" · ");
+      return `<div class="scan-remote">
+        <div><span style="color:#9dccff;">${escapeHtml(j.remote || "?")}</span> · <span>${escapeHtml(j.status || "queued")}</span></div>
+        <div style="color:#777;">${escapeHtml(detail)}</div>
+        ${pct != null ? `<div class="scan-track"><div class="scan-fill" style="width:${pct}%"></div></div>` : ""}
+      </div>`;
+    }).join("");
+    scanJobOut.innerHTML = `
+      <div style="color:#888;margin-bottom:6px;">${escapeHtml(jobLabel)}${when ? ` · ${escapeHtml(when)}` : ""}</div>
+      <div class="scan-job-head"><span class="scan-pill ${pillCls}">${escapeHtml(status)}</span><span>${escapeHtml(summary || "scan job")}</span></div>
+      ${retiredRoots.length ? `<div class="section-note warn" style="margin:0 0 8px;">Historical scan roots not in current config: ${escapeHtml(retiredRoots.join(", "))}. They are shown because this job was recorded before the scan roots changed.</div>` : ""}
+      ${r.error ? `<div style="color:#faa;margin-bottom:6px;">${escapeHtml(r.error)}</div>` : ""}
+      ${jobRows || `<div style="color:#777;">waiting for remote progress...</div>`}
+    `;
+  }
+
+  const _pollOptProgress = () => {
+    chrome.runtime.sendMessage({ type: "scan-progress" }, (r) => {
+      if (chrome.runtime.lastError || !r || !r.ok) return;
+      _renderScanJob(r);
+      if (r.done || !r.scanning) {
+        _stopOptPoll();
+        _setOptScanningState(false);
+        if (r.cancelled) {
+          return;
+        } else if (r.scan_ok !== false) {
+          setTimeout(() => document.getElementById("cache-status-run").click(), 500);
+        }
+        return;
+      }
+    });
+  };
+
+  async function _refreshScanJob() {
+    try {
+      const cache = await chrome.runtime.sendMessage({ type: "cache-status" });
+      if (cache && cache.ok) rememberConfiguredScanRoots(cache);
+    } catch {}
+    _pollOptProgress();
+  }
+
+  async function _startOptScan(scanRoots = [], forceSince = null) {
+    const out = scanJobOut;
+    if (_optScanning) {
+      // Cancel in-progress scan
+      rebuildBtn.disabled = true;
+      rebuildBtn.textContent = "Cancelling…";
+      chrome.runtime.sendMessage({ type: "scan-cancel" }, () => {
+        rebuildBtn.disabled = false;
+        // State will update on next poll tick
+      });
+      return;
+    }
+    // forceSince overrides dropdown (used by per-remote Refresh to stay incremental)
+    const scanSince = forceSince !== null ? forceSince : (rebuildMode ? rebuildMode.value : "");
+    const scope = scanRoots.length ? `refresh ${scanRoots.join(", ")}` : "all configured scan roots";
+    const label = scanSince ? `incrementally update files changed in the last ${scanSince}` : "fully rebuild";
+    const button = scanRoots.length ? "Refresh" : "Rebuild";
+    if (!confirm(`${button} cache now?\n\nScope: ${scope}\nMode: ${label}\n\nThis can take several minutes.`)) return;
+    cacheStatusOut.innerHTML = `<span style="color:#6ec1ff;">starting scan…</span>`;
+    out.innerHTML = "";
+    try {
+      const r = await chrome.runtime.sendMessage({ type: "run-scan", scanSince, scanRoots });
+      if (!r || !r.ok) {
+        out.innerHTML = `<span style="color:#faa;">scan failed:</span> ${escapeHtml(r?.error || "no response")}`;
+        return;
+      }
+      _setOptScanningState(true);
+      _pollOptProgress();
+      _optScanTimer = setInterval(_pollOptProgress, 1500);
+    } catch (err) {
+      out.innerHTML = `<span style="color:#faa;">scan failed:</span> ${escapeHtml(err.message || String(err))}`;
+    }
+  }
+
+  rebuildBtn.addEventListener("click", () => _startOptScan());
+
+  function _renderNonJavPanel(items, remote) {
+    const panel = document.createElement("div");
+    panel.className = "nonjav-panel";
+    panel.dataset.remote = remote;
+    const deleteEnabled = document.getElementById("enableDelete")?.checked;
+    const delBtnHtml = deleteEnabled
+      ? `<button class="nonjav-del-all" type="button" title="Delete all non-JAV files in this remote">Delete All (${items.length})</button>`
+      : `<span style="font-size:11px;color:#555;">Enable deletion in settings to delete</span>`;
+    panel.innerHTML = `
+      <div class="nonjav-panel-head">
+        <span class="nonjav-panel-title">${escapeHtml(remote)} · ${items.length} non-JAV file${items.length !== 1 ? "s" : ""}</span>
+        ${delBtnHtml}
+      </div>
+      <div class="nonjav-list">${items.map(f => `
+        <div class="nonjav-item" data-full-path="${escapeHtml(f.full_path)}">
+          <span class="nonjav-ext">${escapeHtml(f.ext || "?")}</span>
+          <span class="nonjav-path" title="${escapeHtml(f.full_path)}">${escapeHtml(f.path)}</span>
+          ${deleteEnabled ? `<button class="nonjav-del-one" type="button">Delete</button>` : ""}
+        </div>`).join("")}
+      </div>
+      <div class="nonjav-status"></div>`;
+    // Delete one
+    panel.addEventListener("click", async (e) => {
+      const btn = e.target.closest(".nonjav-del-one");
+      if (btn) {
+        const item = btn.closest(".nonjav-item");
+        const path = item?.dataset.fullPath;
+        if (!path) return;
+        if (!confirm(`Delete?\n${path}`)) return;
+        btn.disabled = true;
+        const r = await chrome.runtime.sendMessage({ type: "delete-skipped", paths: [path] });
+        if (r?.ok) {
+          item.classList.add("deleted");
+          item.querySelector(".nonjav-del-one")?.remove();
+          _updateNonJavDelAll(panel);
+        } else {
+          btn.disabled = false;
+          panel.querySelector(".nonjav-status").textContent = "Error: " + (r?.error || "failed");
+        }
+        return;
+      }
+      const delAll = e.target.closest(".nonjav-del-all");
+      if (delAll) {
+        const allItems = [...panel.querySelectorAll(".nonjav-item:not(.deleted)")];
+        const paths = allItems.map(i => i.dataset.fullPath).filter(Boolean);
+        if (!paths.length) return;
+        if (!confirm(`Delete all ${paths.length} non-JAV file(s) from ${remote}?`)) return;
+        delAll.disabled = true;
+        const statusEl = panel.querySelector(".nonjav-status");
+        statusEl.textContent = `Deleting ${paths.length} file(s)…`;
+        const r = await chrome.runtime.sendMessage({ type: "delete-skipped", paths });
+        const ok = r?.deleted_count || 0;
+        const fail = r?.failed_count || 0;
+        if (ok) {
+          // Mark successfully deleted items
+          const deletedPaths = new Set(
+            (r.results || []).filter(x => x.ok).map(x => x.path)
+          );
+          allItems.forEach(i => {
+            if (deletedPaths.has(i.dataset.fullPath)) {
+              i.classList.add("deleted");
+              i.querySelector(".nonjav-del-one")?.remove();
+            }
+          });
+          _updateNonJavDelAll(panel);
+        }
+        statusEl.textContent = fail
+          ? `Deleted ${ok}, failed ${fail}. Check deletion settings.`
+          : `Deleted ${ok} file(s).`;
+      }
+    });
+    return panel;
+  }
+
+  function _updateNonJavDelAll(panel) {
+    const remaining = panel.querySelectorAll(".nonjav-item:not(.deleted)").length;
+    const btn = panel.querySelector(".nonjav-del-all");
+    if (btn) {
+      btn.textContent = `Delete All (${remaining})`;
+      btn.disabled = remaining === 0;
+    }
+  }
+
+  cacheStatusOut.addEventListener("click", (event) => {
+    const showSkipped = event.target.closest(".cache-show-skipped");
+    if (showSkipped) {
+      const remote = showSkipped.dataset.remote;
+      // Toggle: if panel already open, close it
+      const existing = cacheStatusOut.querySelector(`.nonjav-panel[data-remote="${CSS.escape(remote)}"]`);
+      if (existing) { existing.remove(); showSkipped.textContent = showSkipped.textContent.replace("▴", "▾"); return; }
+      showSkipped.textContent = showSkipped.textContent.replace("▾", "▴");
+      // Find skipped items from last cache status result
+      const items = (_cacheSkippedByRemote?.get(remote)) || [];
+      const panel = _renderNonJavPanel(items, remote);
+      // Insert after the row containing this button
+      showSkipped.closest("div")?.after(panel);
+      return;
+    }
+    const refresh = event.target.closest(".cache-refresh-remote");
+    if (refresh) {
+      const remote = refresh.dataset.remote || "";
+      if (!remote) return;
+      // Per-remote Refresh is always incremental — inherit dropdown value if it's a
+      // duration (not "Full Rebuild"), otherwise default to 24h.
+      const dropdownVal = rebuildMode ? rebuildMode.value : "";
+      const refreshSince = dropdownVal || "24h";
+      _startOptScan([remote], refreshSince);
+      return;
+    }
+  });
+
+  document.getElementById("scan-job-clear").addEventListener("click", async () => {
+    if (!confirm("Clear recorded scan job history?\n\nThis only clears the Scan Job panel state. It does not change cache.json.")) return;
+    scanJobOut.textContent = "clearing scan job history...";
+    const r = await chrome.runtime.sendMessage({ type: "scan-clear" });
+    if (!r || !r.ok) {
+      scanJobOut.innerHTML = `<span style="color:#faa;">clear failed:</span> ${escapeHtml(r?.error || "no response")}`;
+      return;
+    }
+    _renderScanJob({ ok: true, no_state: true });
+  });
+
+  // If Options is opened while a scan is already running, attach to it instead
+  // of showing an idle Rebuild button.
+  _refreshScanJob();
+  chrome.runtime.sendMessage({ type: "scan-progress" }, (r) => {
+    if (chrome.runtime.lastError || !r || !r.ok) return;
+    _renderScanJob(r);
+    if (!r.scanning) return;
+    _setOptScanningState(true);
+    _optScanTimer = setInterval(_pollOptProgress, 1500);
+  });
+})();
+
+// ---------- adapters ----------
+
+function renderAdapters(list) {
+  const tbody = document.querySelector("#adapters tbody");
+  tbody.innerHTML = "";
+  for (const a of list) addAdapterRow(a.host || "", a.selector || "");
+  if (list.length === 0) addAdapterRow("", "");
+}
+
+function addAdapterRow(host, selector) {
+  const tbody = document.querySelector("#adapters tbody");
+  const tr = document.createElement("tr");
+  tr.innerHTML = `
+    <td><input type="text" class="host" placeholder="clearjav.com"></td>
+    <td><input type="text" class="selector" placeholder=".some-class"></td>
+    <td><button class="del" type="button">×</button></td>`;
+  tr.querySelector(".host").value = host;
+  tr.querySelector(".selector").value = selector;
+  tr.querySelector(".del").addEventListener("click", () => tr.remove());
+  tbody.appendChild(tr);
+}
+
+function readAdapters() {
+  const rows = document.querySelectorAll("#adapters tbody tr");
+  const out = [];
+  for (const tr of rows) {
+    const host = tr.querySelector(".host").value.trim();
+    const selector = tr.querySelector(".selector").value.trim();
+    if (host && selector) out.push({ host, selector });
+  }
+  return out;
+}
+
+document.getElementById("add-adapter").addEventListener("click", () => addAdapterRow("", ""));
+
+document.getElementById("validate-adapters").addEventListener("click", () => {
+  const status = document.getElementById("picker-status");
+  const rows = [...document.querySelectorAll("#adapters tbody tr")];
+  const seen = new Set();
+  const issues = [];
+  for (const tr of rows) {
+    const host = tr.querySelector(".host").value.trim();
+    const selector = tr.querySelector(".selector").value.trim();
+    tr.style.outline = "";
+    if (!host && !selector) continue;
+    if (!host || !selector) {
+      issues.push("rows need both host and selector");
+      tr.style.outline = "1px solid #775";
+      continue;
+    }
+    const key = host.toLowerCase();
+    if (seen.has(key)) {
+      issues.push(`duplicate host: ${host}`);
+      tr.style.outline = "1px solid #775";
+    }
+    seen.add(key);
+    try { document.querySelector(selector); } catch {
+      issues.push(`invalid CSS selector for ${host}`);
+      tr.style.outline = "1px solid #775";
+    }
+  }
+  status.textContent = issues.length ? [...new Set(issues)].join("; ") : `${readAdapters().length} adapter row(s) look valid`;
+  updateSectionSummaries();
+});
+
+// ---------- ID normalizers ----------
+
+function renderNormalizers(list) {
+  const tbody = document.querySelector("#normalizers tbody");
+  tbody.innerHTML = "";
+  for (const n of list) addNormalizerRow(n.re || "", n.fmt || "");
+  if (list.length === 0) addNormalizerRow("", "");
+}
+
+function addNormalizerRow(re, fmt) {
+  const tbody = document.querySelector("#normalizers tbody");
+  const tr = document.createElement("tr");
+  tr.innerHTML = `
+    <td><input type="text" class="re" placeholder="\\b1pondo-?(\\d{4,})-?(\\d{2,})\\b"></td>
+    <td><input type="text" class="fmt" placeholder="1pondo-$1-$2"></td>
+    <td><button class="del" type="button">×</button></td>`;
+  tr.querySelector(".re").value = re;
+  tr.querySelector(".fmt").value = fmt;
+  tr.querySelector(".del").addEventListener("click", () => tr.remove());
+  tbody.appendChild(tr);
+}
+
+function readNormalizers() {
+  const rows = document.querySelectorAll("#normalizers tbody tr");
+  const out = [];
+  for (const tr of rows) {
+    const re = tr.querySelector(".re").value.trim();
+    const fmt = tr.querySelector(".fmt").value.trim();
+    if (re && fmt) out.push({ re, fmt });
+  }
+  return out;
+}
+
+document.getElementById("add-normalizer").addEventListener("click", () => addNormalizerRow("", ""));
+
+document.getElementById("validate-normalizers").addEventListener("click", () => {
+  const status = document.getElementById("normalizer-status");
+  const rows = [...document.querySelectorAll("#normalizers tbody tr")];
+  const issues = [];
+  for (const tr of rows) {
+    tr.style.outline = "";
+    const re = tr.querySelector(".re").value.trim();
+    const fmt = tr.querySelector(".fmt").value.trim();
+    if (!re && !fmt) continue;
+    if (!re || !fmt) {
+      issues.push("rows need both regex and replacement");
+      tr.style.outline = "1px solid #775";
+      continue;
+    }
+    try { new RegExp(re, "i"); } catch (err) {
+      issues.push(`invalid regex: ${err.message}`);
+      tr.style.outline = "1px solid #775";
+    }
+  }
+  status.textContent = issues.length ? issues.join("; ") : `${readNormalizers().length} normalizer row(s) look valid`;
+  updateSectionSummaries();
+});
+
+// ---------- custom part detectors ----------
+
+const PART_DETECTOR_SAMPLES = [
+  "KV-118 - Aiba Reika_PART1.mp4",
+  "KV-118 - Aiba Reika_PART2.mp4",
+  "KV-118 - Aiba Reika_PART3.mp4",
+  "KV-118_1.mp4",
+  "KV-118_2.mp4",
+  "KV-118-pt1.mp4",
+  "KV-118-part2.mp4",
+  "KV-118-cd1.mp4",
+  "KV-118-disc2.mp4",
+  "KV-118 (1).mp4",
+  "KV-118 (1 of 3).mp4",
+  "KV-118.1of3.mp4",
+  "KV-118-2 of 4.mp4",
+  "OFJE-195-1 [480p].mp4",
+  "OFJE-195-2 [480p].mp4",
+  "OFJE-195-3 [480p].mp4",
+  "KV-118_A.mp4",
+  "KV-118-B.mp4",
+  "KV-118A.mp4",
+  "KV-118 1.mp4",
+  "KV-118-P1.mp4",
+  "KV-118_P2.mp4",
+  "KV-118 Part 3.mp4",
+  "KV-118_EP1.mp4",
+  "KV-118 Episode 2.mp4",
+  "KV-118_Vol1.mp4",
+  "KV-118 Volume 2.mp4",
+  "KV-118_Scene1.mp4",
+  "KV-118_Side-A.mp4",
+];
+
+const BUILTIN_PART_DETECTORS = [
+  { pattern: "[-_ ](?:pt|part|cd|disc)[-_ ]?(\\d+)$", note: "pt / part / cd / disc number" },
+  { pattern: "\\s*\\((\\d+)(?:\\s*of\\s*\\d+)?\\)$", note: "parenthesized part number or X of Y" },
+  { pattern: "[._ -](\\d+)\\s*of\\s*\\d+$", note: "X of Y suffix" },
+  { pattern: "_(\\d{1,2})$", note: "underscore number" },
+  { pattern: "-(\\d{1,2})$", note: "hyphen short part number" },
+  { pattern: "[-_]([A-D])$", note: "lettered part with separator" },
+  { pattern: "(?<=\\d)([A-D])$", note: "lettered part directly after ID" },
+  { pattern: "\\s+(\\d{1,2})$", note: "trailing spaced number" },
+];
+
+function partDetectorStem(filename) {
+  return filename.replace(/\.[^.]+$/, "");
+}
+
+function partDetectorStemStages(filename) {
+  const raw = partDetectorStem(filename);
+  const resolutionClean = raw.replace(/\s*\[[^\]]*\]\s*$/, "").trim();
+  let actressClean = resolutionClean;
+  if (actressClean.includes(" - ")) actressClean = actressClean.slice(0, actressClean.indexOf(" - ")).trim();
+  const stages = [];
+  for (const [label, stem] of [
+    ["raw stem", raw],
+    ["after trailing metadata cleanup", resolutionClean],
+    ["after actress cleanup", actressClean],
+  ]) {
+    if (stem && !stages.some((stage) => stage.stem === stem)) stages.push({ label, stem });
+  }
+  return stages;
+}
+
+function partDetectorRegex(pattern) {
+  // Custom detectors are Python regexes, but the common detector subset is
+  // shared with browser RegExp. Preview the representative shapes here; rc-jav
+  // remains authoritative when the saved rule runs during scan/search.
+  return new RegExp(pattern, "i");
+}
+
+function builtinPartCoverage(filename) {
+  for (const detector of BUILTIN_PART_DETECTORS) {
+    try {
+      const re = partDetectorRegex(detector.pattern);
+      for (const stage of partDetectorStemStages(filename)) {
+        const match = stage.stem.match(re);
+        if (match && match[1]) return detector;
+      }
+    } catch {}
+  }
+  return null;
+}
+
+function updatePartDetectorFeedback(row) {
+  const feedback = row.querySelector(".part-detector-feedback");
+  const pattern = row.querySelector(".part-detector-pattern").value.trim();
+  if (!pattern) {
+    feedback.innerHTML = `<span class="warn">Enter a detector regex.</span> Capture group 1 should be the part token.`;
+    return;
+  }
+  let re;
+  try {
+    re = partDetectorRegex(pattern);
+  } catch (err) {
+    feedback.innerHTML = `<span class="fail">Invalid preview regex:</span> ${escapeHtml(err.message || String(err))}`;
+    return;
+  }
+  const matches = [];
+  let missingCapture = false;
+  for (const filename of PART_DETECTOR_SAMPLES) {
+    for (const stage of partDetectorStemStages(filename)) {
+      const match = stage.stem.match(re);
+      if (!match) continue;
+      if (!match[1]) missingCapture = true;
+      matches.push({ filename, part: match[1] || "?", stage: stage.label });
+      break;
+    }
+  }
+  if (!matches.length) {
+    feedback.innerHTML = `<span class="warn">No representative sample matched.</span> The rule may still be valid for a library-specific filename shape.`;
+    return;
+  }
+  const isBuiltin = row.classList.contains("builtin");
+  const covered = !isBuiltin ? matches.map((item) => ({ item, detector: builtinPartCoverage(item.filename) })) : [];
+  const alreadyCovered = covered.length && covered.every((entry) => entry.detector);
+  const coveredNote = alreadyCovered
+    ? `<div class="warn">These representative matches are already covered by built-in detector${new Set(covered.map((entry) => entry.detector.pattern)).size === 1 ? "" : "s"}.</div>`
+    : "";
+  feedback.innerHTML = [
+    `<span class="${missingCapture ? "warn" : "ok"}">${missingCapture ? "Matched, but capture group 1 was missing for a sample." : `Matches ${matches.length} representative filename shape${matches.length === 1 ? "" : "s"}.`}</span>`,
+    coveredNote,
+    ...matches.slice(0, 4).map((item) => `<div class="part-detector-match">${escapeHtml(item.filename)} -> part ${escapeHtml(item.part)} <span style="color:#777;">(${escapeHtml(item.stage)})</span></div>`),
+    matches.length > 4 ? `<div>and ${escapeHtml(matches.length - 4)} more representative match(es)</div>` : "",
+  ].filter(Boolean).join("");
+}
+
+function addPartDetectorRow(pattern = "", { builtin = false, note = "" } = {}) {
+  const list = document.getElementById(builtin ? "builtin-part-detectors" : "part-detectors");
+  const row = document.createElement("div");
+  row.className = "part-detector-row" + (builtin ? " builtin" : "");
+  row.innerHTML = `
+    <div class="part-detector-head">
+      <input type="text" class="part-detector-pattern" placeholder="_PART(\\d+)$"${builtin ? " readonly" : ""}>
+      ${builtin ? `<span class="part-detector-kind">Built in</span>` : `<button type="button" title="Remove detector">x</button>`}
+    </div>
+    ${note ? `<div class="muted" style="margin-top:5px;">${escapeHtml(note)}</div>` : ""}
+    <div class="part-detector-feedback"></div>
+  `;
+  row.querySelector(".part-detector-pattern").value = pattern;
+  if (!builtin) {
+    row.querySelector(".part-detector-pattern").addEventListener("input", () => {
+      updatePartDetectorFeedback(row);
+      updateSectionSummaries();
+    });
+    row.querySelector("button").addEventListener("click", () => {
+      row.remove();
+      if (!list.children.length) addPartDetectorRow("");
+      updateSectionSummaries();
+    });
+  }
+  list.appendChild(row);
+  updatePartDetectorFeedback(row);
+  return row;
+}
+
+function renderPartDetectors(patterns) {
+  const builtinList = document.getElementById("builtin-part-detectors");
+  const list = document.getElementById("part-detectors");
+  builtinList.innerHTML = "";
+  list.innerHTML = "";
+  for (const detector of BUILTIN_PART_DETECTORS) addPartDetectorRow(detector.pattern, { builtin: true, note: detector.note });
+  for (const pattern of patterns || []) addPartDetectorRow(pattern);
+  if (!list.children.length) addPartDetectorRow("");
+}
+
+function readPartDetectors() {
+  return [...document.querySelectorAll("#part-detectors .part-detector-pattern")]
+    .map((input) => input.value.trim())
+    .filter(Boolean);
+}
+
+document.getElementById("add-part-detector").addEventListener("click", () => {
+  addPartDetectorRow("").querySelector(".part-detector-pattern").focus();
+});
+
+// Tester
+document.getElementById("norm-test-run").addEventListener("click", async () => {
+  const input = document.getElementById("norm-test-in").value;
+  const out = document.getElementById("norm-test-out");
+  out.textContent = "testing text...";
+  try {
+    const r = await chrome.runtime.sendMessage({
+      type: "test-id-text",
+      text: input,
+      normalizers: readNormalizers(),
+    });
+    if (!r || !r.ok) {
+      out.innerHTML = `<span style="color:#faa;">error:</span> ${escapeHtml(r?.error || "no response")}`;
+      return;
+    }
+    const e = r.extracted || {};
+    out.innerHTML = [
+      `<div><span style="color:#777;">ID:</span> <span style="color:${e.id ? "#afa" : "#faa"};">${escapeHtml(e.id || "none")}</span></div>`,
+      `<div><span style="color:#777;">Rule:</span> ${escapeHtml(e.source || "none")}</div>`,
+      e.pattern ? `<div><span style="color:#777;">Pattern:</span> ${escapeHtml(e.pattern)}</div>` : "",
+      e.replacement ? `<div><span style="color:#777;">Replacement:</span> ${escapeHtml(e.replacement)}</div>` : "",
+      e.raw ? `<div><span style="color:#777;">Raw:</span> ${escapeHtml(e.raw)}</div>` : "",
+    ].filter(Boolean).join("");
+  } catch (err) {
+    out.innerHTML = `<span style="color:#faa;">error:</span> ${escapeHtml(err.message || String(err))}`;
+  }
+});
+
+// ---------- element picker ----------
+
+// Track the active picker poll so re-clicking "Pick Element" cancels the prior
+// poll instead of leaving two racing on the same session-storage key.
+let activePickerPoll = null;
+window.addEventListener("pagehide", () => {
+  if (activePickerPoll != null) { clearInterval(activePickerPoll); activePickerPoll = null; }
+});
+
+async function startPicker() {
+  const status = document.getElementById("picker-status");
+  if (activePickerPoll != null) {
+    clearInterval(activePickerPoll);
+    activePickerPoll = null;
+    // Drop any stale prior result so the new poll doesn't see it.
+    await chrome.storage.session.remove("lastPickerResult");
+  }
+  status.textContent = "starting picker…";
+  const resp = await chrome.runtime.sendMessage({ type: "start-picker", from: "options" });
+  if (!resp || !resp.ok) {
+    status.textContent = "error: " + (resp?.error || "no response");
+    return;
+  }
+  status.textContent = `picker armed on: ${resp.url || "(unknown tab)"} — click an element, Esc to cancel`;
+  const start = Date.now();
+  const poll = setInterval(async () => {
+    const { lastPickerResult } = await chrome.storage.session.get("lastPickerResult");
+    if (lastPickerResult && lastPickerResult.ts > start) {
+      clearInterval(poll); activePickerPoll = null;
+      await chrome.storage.session.remove("lastPickerResult");
+      if (lastPickerResult.type === "picker-cancelled") {
+        status.textContent = "cancelled";
+        return;
+      }
+      const host = lastPickerResult.host || "";
+      const hostPattern = host ? host.replace(/^www\./, "") : "";
+      const selector = lastPickerResult.selector || "";
+      const rows = document.querySelectorAll("#adapters tbody tr");
+      let replaced = false;
+      for (const tr of rows) {
+        const existing = tr.querySelector(".host").value.trim().toLowerCase();
+        if (existing === hostPattern.toLowerCase()) {
+          tr.querySelector(".selector").value = selector;
+          replaced = true;
+          break;
+        }
+      }
+      if (!replaced) addAdapterRow(hostPattern, selector);
+      for (const tr of document.querySelectorAll("#adapters tbody tr")) {
+        const h = tr.querySelector(".host").value.trim();
+        const s = tr.querySelector(".selector").value.trim();
+        if (!h && !s) tr.remove();
+      }
+      status.textContent = `${replaced ? "updated" : "added"}: ${selector} (sample: "${(lastPickerResult.sample || "").slice(0, 60)}", detected: ${lastPickerResult.detectedId || "no ID"})`;
+    }
+    if (Date.now() - start > 120000) {
+      clearInterval(poll); activePickerPoll = null;
+      status.textContent = "timed out (2 min)";
+    }
+  }, 500);
+  activePickerPoll = poll;
+}
+
+document.getElementById("pick-element").addEventListener("click", startPicker);
+
+document.getElementById("test-active-page").addEventListener("click", async () => {
+  const wrap = document.getElementById("adapter-test-result");
+  const out = document.getElementById("adapter-test-output");
+  wrap.style.display = "";
+  out.textContent = "testing active page...";
+  try {
+    const r = await chrome.runtime.sendMessage({
+      type: "test-active-page",
+      adapters: readAdapters(),
+      normalizers: readNormalizers(),
+    });
+    if (!r || !r.ok) {
+      out.innerHTML = `<span style="color:#faa;">error:</span> ${escapeHtml(r?.error || "no response")}`;
+      return;
+    }
+    const e = r.extracted || {};
+    const selected = e.selected || {};
+    const stage = (name, value) => `<div><span style="color:#777;">${escapeHtml(name)}:</span> <span style="color:${value?.id ? "#afa" : "#666"};">${escapeHtml(value?.id || "none")}</span>${value?.raw ? ` · ${escapeHtml(value.raw)}` : ""}</div>`;
+    out.innerHTML = [
+      `<div><span style="color:#777;">ID:</span> <span style="color:${e.id ? "#afa" : "#faa"};">${escapeHtml(e.id || "none")}</span></div>`,
+      `<div><span style="color:#777;">Source:</span> ${escapeHtml(e.source || "none")}</div>`,
+      selected.adapter ? `<div><span style="color:#777;">Adapter:</span> ${escapeHtml(selected.adapter)}</div>` : "",
+      selected.selector ? `<div><span style="color:#777;">Selector:</span> ${escapeHtml(selected.selector)}</div>` : "",
+      selected.raw ? `<div><span style="color:#777;">Selected raw:</span> ${escapeHtml(selected.raw)}</div>` : "",
+      `<div style="margin-top:5px;color:#888;">Stage trace</div>`,
+      stage("Adapter", e.stages?.adapter),
+      stage("Title", e.stages?.title),
+      stage("URL", e.stages?.url),
+      `<div><span style="color:#777;">URL:</span> ${escapeHtml(r.tab?.url || "")}</div>`,
+      `<div><span style="color:#777;">Title:</span> ${escapeHtml(r.tab?.title || "")}</div>`,
+    ].filter(Boolean).join("");
+  } catch (err) {
+    out.innerHTML = `<span style="color:#faa;">error:</span> ${escapeHtml(err.message || String(err))}`;
+  }
+});
+
+// ---------- radio chips selected styling ----------
+
+function syncRadioChips() {
+  const trashLbl = document.getElementById("deleteModeTrashLbl");
+  const permLbl = document.getElementById("deleteModePermLbl");
+  trashLbl.classList.toggle("selected", document.getElementById("deleteModeTrash").checked);
+  permLbl.classList.toggle("selected", document.getElementById("deleteModePerm").checked);
+  permLbl.classList.add("danger");  // permanent always carries the danger style; .selected.danger = red
+}
+document.getElementById("deleteModeTrash").addEventListener("change", syncRadioChips);
+document.getElementById("deleteModePerm").addEventListener("change", syncRadioChips);
+
+function syncOverlayPosChips() {
+  for (const r of document.querySelectorAll('input[name="overlayPosition"]')) {
+    r.parentElement.classList.toggle("selected", r.checked);
+  }
+}
+for (const r of document.querySelectorAll('input[name="overlayPosition"]')) {
+  r.addEventListener("change", () => { syncOverlayPosChips(); updateOverlayPreview(); });
+}
+
+// ---------- live overlay preview ----------
+
+function hexToRgba(hex, a) {
+  const m = String(hex).match(/^#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
+  if (!m) return `rgba(110,193,255,${a})`;
+  return `rgba(${parseInt(m[1], 16)},${parseInt(m[2], 16)},${parseInt(m[3], 16)},${a})`;
+}
+
+function updateOverlayPreview() {
+  const preview = document.getElementById("overlay-preview");
+  const stage = document.getElementById("overlay-preview-stage");
+  const posLabel = document.getElementById("overlay-preview-pos");
+  if (!preview) return;
+  const pos = (document.querySelector('input[name="overlayPosition"]:checked') || {}).value || "top-right";
+  const glow = document.getElementById("overlayGlow").checked;
+  const color = document.getElementById("overlayGlowColor").value || "#6ec1ff";
+  const blur = parseInt(document.getElementById("overlayGlowBlur").value, 10) || 0;
+  const spread = parseInt(document.getElementById("overlayGlowSpread").value, 10) || 0;
+  const opacity = parseFloat(document.getElementById("overlayGlowOpacity").value) || 0.35;
+  const dur = Math.max(1, parseInt(document.getElementById("overlayDuration").value, 10) || 5);
+
+  // Stage alignment hints at chosen position
+  stage.style.alignItems = pos.startsWith("top") ? "flex-start" : "flex-end";
+  stage.style.justifyContent = pos.endsWith("left") ? "flex-start" : "flex-end";
+  posLabel.textContent = `— ${pos} · ${dur}s · ${glow ? "glow on" : "no glow"}`;
+
+  // Reflect slider values
+  document.getElementById("overlayGlowBlurVal").textContent = `${blur} px`;
+  document.getElementById("overlayGlowSpreadVal").textContent = `${spread} px`;
+  document.getElementById("overlayGlowOpacityVal").textContent = opacity.toFixed(2);
+
+  preview.style.boxShadow = glow
+    ? `0 6px 20px rgba(0,0,0,0.55), 0 0 ${blur}px ${spread}px ${hexToRgba(color, opacity)}`
+    : "0 6px 20px rgba(0,0,0,0.55)";
+
+  // Restart progress bar animation with current duration
+  const bar = document.getElementById("overlay-preview-bar");
+  bar.style.animation = "none";
+  // force reflow
+  void bar.offsetWidth;
+  bar.style.animation = `rxshrink-preview ${dur}s linear infinite`;
+}
+
+// Inject keyframes once
+(function injectPreviewKeyframes() {
+  const s = document.createElement("style");
+  s.textContent = "@keyframes rxshrink-preview { from { transform: scaleX(1); } to { transform: scaleX(0); } }";
+  document.head.appendChild(s);
+})();
+
+document.getElementById("overlayGlow").addEventListener("change", updateOverlayPreview);
+document.getElementById("overlayGlowColor").addEventListener("input", updateOverlayPreview);
+document.getElementById("overlayDuration").addEventListener("input", updateOverlayPreview);
+document.getElementById("overlayGlowBlur").addEventListener("input", updateOverlayPreview);
+document.getElementById("overlayGlowSpread").addEventListener("input", updateOverlayPreview);
+document.getElementById("overlayGlowOpacity").addEventListener("input", updateOverlayPreview);
+document.getElementById("overlay-preview-replay").addEventListener("click", updateOverlayPreview);
+
+// ---------- no-match overlay ----------
+
+function syncNoMatchPosChips() {
+  for (const r of document.querySelectorAll('input[name="noMatchPosition"]')) {
+    r.parentElement.classList.toggle("selected", r.checked);
+  }
+}
+
+function updateMutualExclusion() {
+  // Disable the radio in noMatchPosition that matches the chosen overlayPosition.
+  const matchPos = (document.querySelector('input[name="overlayPosition"]:checked') || {}).value;
+  for (const r of document.querySelectorAll('input[name="noMatchPosition"]')) {
+    const same = r.value === matchPos;
+    r.disabled = same;
+    r.parentElement.style.opacity = same ? "0.4" : "";
+    r.parentElement.style.pointerEvents = same ? "none" : "";
+    if (same && r.checked) {
+      // Auto-switch to first non-disabled
+      r.checked = false;
+      const fallback = Array.from(document.querySelectorAll('input[name="noMatchPosition"]'))
+        .find((x) => x.value !== matchPos);
+      if (fallback) fallback.checked = true;
+      syncNoMatchPosChips();
+      updateNoMatchPreview();
+    }
+  }
+  // Same in reverse for overlayPosition (disable noMatch's selected one)
+  const nmPos = (document.querySelector('input[name="noMatchPosition"]:checked') || {}).value;
+  for (const r of document.querySelectorAll('input[name="overlayPosition"]')) {
+    const same = r.value === nmPos && document.getElementById("noMatchOverlay").checked;
+    r.disabled = same;
+    r.parentElement.style.opacity = same ? "0.4" : "";
+    r.parentElement.style.pointerEvents = same ? "none" : "";
+  }
+}
+
+function updateNoMatchPreview() {
+  const preview = document.getElementById("no-match-preview");
+  const stage = document.getElementById("no-match-preview-stage");
+  const posLabel = document.getElementById("no-match-preview-pos");
+  if (!preview) return;
+  const pos = (document.querySelector('input[name="noMatchPosition"]:checked') || {}).value || "top-right";
+  const glow = document.getElementById("noMatchGlow").checked;
+  const color = document.getElementById("noMatchGlowColor").value || "#ff6666";
+  const blur = parseInt(document.getElementById("noMatchGlowBlur").value, 10) || 0;
+  const spread = parseInt(document.getElementById("noMatchGlowSpread").value, 10) || 0;
+  const opacity = parseFloat(document.getElementById("noMatchGlowOpacity").value) || 0.35;
+  const dur = Math.max(1, parseInt(document.getElementById("noMatchDuration").value, 10) || 5);
+
+  stage.style.alignItems = pos.startsWith("top") ? "flex-start" : "flex-end";
+  stage.style.justifyContent = pos.endsWith("left") ? "flex-start" : "flex-end";
+  posLabel.textContent = `— ${pos} · ${dur}s · ${glow ? "glow on" : "no glow"}`;
+
+  document.getElementById("noMatchGlowBlurVal").textContent = `${blur} px`;
+  document.getElementById("noMatchGlowSpreadVal").textContent = `${spread} px`;
+  document.getElementById("noMatchGlowOpacityVal").textContent = opacity.toFixed(2);
+
+  preview.style.boxShadow = glow
+    ? `0 6px 20px rgba(0,0,0,0.55), 0 0 ${blur}px ${spread}px ${hexToRgba(color, opacity)}`
+    : "0 6px 20px rgba(0,0,0,0.55)";
+
+  const bar = document.getElementById("no-match-preview-bar");
+  bar.style.animation = "none";
+  void bar.offsetWidth;
+  bar.style.animation = `rxshrink-preview ${dur}s linear infinite`;
+}
+
+for (const r of document.querySelectorAll('input[name="noMatchPosition"]')) {
+  r.addEventListener("change", () => { syncNoMatchPosChips(); updateNoMatchPreview(); updateMutualExclusion(); });
+}
+for (const id of ["noMatchOverlay", "noMatchGlow"]) {
+  document.getElementById(id).addEventListener("change", () => { updateNoMatchPreview(); updateMutualExclusion(); });
+}
+for (const id of ["noMatchGlowColor", "noMatchDuration", "noMatchGlowBlur", "noMatchGlowSpread", "noMatchGlowOpacity"]) {
+  document.getElementById(id).addEventListener("input", updateNoMatchPreview);
+}
+document.getElementById("no-match-preview-replay").addEventListener("click", updateNoMatchPreview);
+
+// When match position changes, re-evaluate mutual exclusion
+for (const r of document.querySelectorAll('input[name="overlayPosition"]')) {
+  r.addEventListener("change", updateMutualExclusion);
+}
+
+document.getElementById("no-match-reset").addEventListener("click", () => {
+  document.getElementById("noMatchOverlay").checked = false;
+  for (const r of document.querySelectorAll('input[name="noMatchPosition"]')) {
+    r.checked = r.value === "top-right";
+  }
+  syncNoMatchPosChips();
+  document.getElementById("noMatchDuration").value = 5;
+  document.getElementById("noMatchGlow").checked = false;
+  document.getElementById("noMatchGlowColor").value = "#ff6666";
+  document.getElementById("noMatchGlowBlur").value = 10;
+  document.getElementById("noMatchGlowSpread").value = 0;
+  document.getElementById("noMatchGlowOpacity").value = 0.35;
+  updateNoMatchPreview();
+  updateMutualExclusion();
+  updateSectionSummaries();
+});
+
+document.getElementById("overlay-reset").addEventListener("click", () => {
+  // Reset all overlay-related form fields to defaults.
+  document.getElementById("showOverlay").checked = true;
+  for (const r of document.querySelectorAll('input[name="overlayPosition"]')) {
+    r.checked = r.value === "top-right";
+  }
+  syncOverlayPosChips();
+  document.getElementById("overlayDuration").value = 5;
+  document.getElementById("overlayGlow").checked = false;
+  document.getElementById("overlayGlowColor").value = "#6ec1ff";
+  document.getElementById("overlayGlowBlur").value = 10;
+  document.getElementById("overlayGlowSpread").value = 0;
+  document.getElementById("overlayGlowOpacity").value = 0.35;
+  updateOverlayPreview();
+  updateSectionSummaries();
+});
+
+
+// ---------- diagnostics ----------
+
+// Extension ID display + copy button (added when Transfer Assistant was deleted).
+// Diagnostics is the canonical home for "what's my extension ID?" info now.
+(() => {
+  const idEl = document.getElementById("diag-extension-id");
+  const copyBtn = document.getElementById("diag-copy-extension-id");
+  if (idEl) idEl.textContent = chrome.runtime.id;
+  if (copyBtn) {
+    copyBtn.addEventListener("click", async () => {
+      try {
+        await navigator.clipboard.writeText(chrome.runtime.id);
+        copyBtn.textContent = "Copied";
+        setTimeout(() => { copyBtn.textContent = "Copy ID"; }, 1200);
+      } catch (_) {
+        copyBtn.textContent = "Copy failed";
+        setTimeout(() => { copyBtn.textContent = "Copy ID"; }, 1200);
+      }
+    });
+  }
+})();
+
+document.getElementById("run-diag").addEventListener("click", (event) =>
+  keepActionViewport(event.currentTarget, runDiagnostics)
+);
+document.getElementById("host-status-run").addEventListener("click", (event) =>
+  keepActionViewport(event.currentTarget, runHostStatus)
+);
+document.getElementById("host-repair-run").addEventListener("click", (event) =>
+  keepActionViewport(event.currentTarget, runHostRepair)
+);
+document.getElementById("host-verify-run").addEventListener("click", (event) =>
+  keepActionViewport(event.currentTarget, runHostStatus)
+);
+document.getElementById("run-all-diag").addEventListener("click", (event) =>
+  keepActionViewport(event.currentTarget, async () => {
+    clearNativeRepairCard();
+    const runtime = await runDiagnostics();
+    if (runtime && runtime.nativeBlocked) {
+      renderBlockedByNativeIssue(document.getElementById("host-status-results"), "Host registration");
+      return;
+    }
+    await runHostStatus();
+  })
+);
+
+function renderDiagRows(out, checks, emptyLabel) {
+  out.innerHTML = "";
+  if (!checks || checks.length === 0) {
+    out.innerHTML = `<div class="diag-row warn"><span class="icon">!</span><span class="name">${escapeHtml(emptyLabel)}</span><span class="detail">no checks returned</span></div>`;
+    return;
+  }
+  const counts = checks.reduce((acc, c) => {
+    const status = c.status || "warn";
+    acc[status] = (acc[status] || 0) + 1;
+    return acc;
+  }, {});
+  const summary = document.createElement("div");
+  summary.className = "diag-row " + ((counts.fail || 0) ? "fail" : (counts.warn || 0) ? "warn" : "ok");
+  summary.innerHTML = `<span class="icon">#</span><span class="name">summary</span><span class="detail">${checks.length} checks · ok ${counts.ok || 0} · info ${counts.info || 0} · warn ${counts.warn || 0} · fail ${counts.fail || 0}</span>`;
+  out.appendChild(summary);
+  for (const c of checks) {
+    const row = document.createElement("div");
+    row.className = "diag-row " + (c.status || "warn");
+    const status = c.status || "warn";
+    const icon = status === "ok" ? "✓" : status === "info" ? "i" : status === "warn" ? "!" : "✗";
+    row.innerHTML = `<span class="icon">${icon}</span><span class="name">${escapeHtml(c.name)}</span><span class="detail">${formatDiagDetail(c.detail || "")}</span>`;
+    out.appendChild(row);
+  }
+}
+
+function formatDiagDetail(detail) {
+  const text = String(detail || "");
+  if (!text) return "";
+  const shouldCollapse = text.length > 120 || text.includes("\n") || (text.match(/[;|]/g) || []).length > 2;
+  if (!shouldCollapse) return escapeHtml(text);
+  const first = text.split(/\r?\n/)[0].slice(0, 110);
+  return `<details><summary>${escapeHtml(first)}${text.length > first.length ? "…" : ""}</summary><pre>${escapeHtml(text)}</pre></details>`;
+}
+
+async function runDiagnostics() {
+  const out = document.getElementById("diag-results");
+  clearNativeRepairCard();
+  out.innerHTML = '<div class="diag-row warn"><span class="icon">…</span><span class="name">running…</span><span class="detail">waiting for native host</span></div>';
+  try {
+    const r = await chrome.runtime.sendMessage({ type: "diagnostics" });
+    if (!r || !r.ok) {
+      await renderNativeMessagingFailure(r);
+      renderBlockedByNativeIssue(out, "Runtime diagnostics");
+      return { nativeBlocked: true };
+    }
+    renderDiagRows(out, r.checks || [], "runtime");
+    return { ok: true };
+  } catch (err) {
+    out.innerHTML = `<div class="diag-row fail"><span class="icon">✗</span><span class="name">runtime</span><span class="detail">${escapeHtml(err.message || String(err))}</span></div>`;
+    return { ok: false };
+  }
+}
+
+async function runHostStatus() {
+  const out = document.getElementById("host-status-results");
+  clearNativeRepairCard();
+  out.innerHTML = '<div class="diag-row warn"><span class="icon">…</span><span class="name">checking…</span><span class="detail">reading manifest and registry state</span></div>';
+  try {
+    const r = await chrome.runtime.sendMessage({ type: "host-status" });
+    if (!r || !r.ok) {
+      await renderNativeMessagingFailure(r);
+      renderBlockedByNativeIssue(out, "Native host checks");
+      return { nativeBlocked: true };
+    }
+    renderDiagRows(out, r.checks || [], "host status");
+    return { ok: true };
+  } catch (err) {
+    out.innerHTML = `<div class="diag-row fail"><span class="icon">✗</span><span class="name">host status</span><span class="detail">${escapeHtml(err.message || String(err))}</span></div>`;
+    return { ok: false };
+  }
+}
+
+async function runHostRepair() {
+  const out = document.getElementById("host-status-results");
+  clearNativeRepairCard();
+  out.innerHTML = '<div class="diag-row warn"><span class="icon">…</span><span class="name">repairing…</span><span class="detail">updating reachable native host manifest and user registration</span></div>';
+  try {
+    const r = await chrome.runtime.sendMessage({ type: "repair-host" });
+    if (!r || !r.ok) {
+      if (r?.error_kind) {
+        await renderNativeMessagingFailure(r);
+        renderBlockedByNativeIssue(out, "Registration repair");
+      } else {
+        out.innerHTML = `<div class="diag-row fail"><span class="icon">✗</span><span class="name">Registration repair</span><span class="detail">${escapeHtml(r?.error || "repair failed")}</span></div>`;
+      }
+      return { ok: false };
+    }
+    const checks = r.verification?.checks || [];
+    renderDiagRows(out, checks, "repair verification");
+    renderCompletedNativeRepair(r);
+    return { ok: true };
+  } catch (err) {
+    out.innerHTML = `<div class="diag-row fail"><span class="icon">✗</span><span class="name">Registration repair</span><span class="detail">${escapeHtml(err.message || String(err))}</span></div>`;
+    return { ok: false };
+  }
+}
+
+function clearNativeRepairCard() {
+  const card = document.getElementById("native-repair-card");
+  const out = document.getElementById("native-repair-results");
+  const title = document.getElementById("native-repair-title");
+  if (card) card.style.display = "none";
+  if (out) out.innerHTML = "";
+  if (title) title.textContent = "Native host setup";
+}
+
+function renderCompletedNativeRepair(response) {
+  const card = document.getElementById("native-repair-card");
+  const out = document.getElementById("native-repair-results");
+  if (!card || !out) return;
+  card.style.display = "";
+  const title = document.getElementById("native-repair-title");
+  if (title) title.textContent = "Registration repair completed";
+  const regs = (response.registrations || []).filter((x) => x.status === "ok").length;
+  out.innerHTML = `
+    <div class="diag-row ok"><span class="icon">✓</span><span class="name">Repair applied</span><span class="detail">${escapeHtml(response.message || "native host registration repaired")}</span></div>
+    <div class="diag-row info"><span class="icon">i</span><span class="name">Manifest</span><span class="detail">${escapeHtml(response.manifest_path || "")}</span></div>
+    <div class="diag-row info"><span class="icon">i</span><span class="name">User registry</span><span class="detail">${escapeHtml(`${regs} HKCU registration entr${regs === 1 ? "y" : "ies"} updated`)}</span></div>
+    <div class="diag-row warn"><span class="icon">!</span><span class="name">Restart required</span><span class="detail">Fully close Brave, reopen it, reload the extension, then click Verify Registration. If Brave still blocks the host, run the registration steps shown by Diagnostics.</span></div>
+  `;
+}
+
+function renderBlockedByNativeIssue(out, title) {
+  out.innerHTML = `<div class="diag-row info"><span class="icon">i</span><span class="name">${escapeHtml(title)}</span><span class="detail">Blocked until this PC registers the native host for the current extension ID. Use the setup card above.</span></div>`;
+}
+
+async function getPackagedHostPaths() {
+  try {
+    const resp = await fetch(chrome.runtime.getURL("host/com.rcjav.host.json"));
+    if (!resp.ok) return {};
+    const manifest = await resp.json();
+    const bat = manifest.path || "";
+    const hostDir = bat.replace(/[\\/][^\\/]+$/, "");
+    return {
+      hostBat: bat,
+      hostDir,
+      registerBat: hostDir ? hostDir + "\\register-host.bat" : "",
+      installPs1: hostDir ? hostDir + "\\install-host.ps1" : "",
+    };
+  } catch {
+    return {};
+  }
+}
+
+async function renderNativeMessagingFailure(response) {
+  const card = document.getElementById("native-repair-card");
+  const out = document.getElementById("native-repair-results");
+  if (!card || !out) return;
+  card.style.display = "";
+  const title = document.getElementById("native-repair-title");
+  if (title) title.textContent = "Register host on this PC";
+  const error = response?.error || "no response";
+  const kind = response?.error_kind || (/forbidden/i.test(error) ? "forbidden" : "unknown");
+  const extensionId = response?.extension_id || chrome.runtime.id;
+  const paths = await getPackagedHostPaths();
+  const installCommand = paths.installPs1
+    ? `pwsh -ExecutionPolicy Bypass -File "${paths.installPs1}" -ExtensionId ${extensionId}`
+    : `pwsh -ExecutionPolicy Bypass -File ".\\host\\install-host.ps1" -ExtensionId ${extensionId}`;
+  const registerCommand = paths.registerBat ? `"${paths.registerBat}"` : ".\\host\\register-host.bat";
+  let cause = "This extension cannot launch the native messaging host yet.";
+  let fix = "Register the host for this extension ID, fully restart Brave, then verify registration.";
+  if (kind === "forbidden") {
+    cause = "Brave found the native host, but this extension ID is not allowed to launch it on this PC.";
+    fix = "This usually happens after loading the extension on another PC or under a different extension ID.";
+  } else if (kind === "not_found") {
+    cause = "Brave could not find a registered native messaging host for com.rcjav.host on this PC.";
+    fix = "Run the registration script from the extension host folder.";
+  } else if (kind === "disconnected") {
+    cause = "The native host started and then disconnected or crashed.";
+    fix = "After registration is fixed, run Runtime diagnostics again to check Python, rc-jav, and rclone.";
+  } else if (kind === "timeout") {
+    cause = "The native host did not respond before the timeout.";
+    fix = "Restart Brave and check whether a scan or rclone command is stuck.";
+  }
+  out.innerHTML = `
+    <div class="diag-row warn"><span class="icon">!</span><span class="name">Setup required</span><span class="detail">Native host registration must be fixed before cache, runtime, and host checks can run.</span></div>
+    <div class="diag-row warn"><span class="icon">!</span><span class="name">Likely cause</span><span class="detail">${escapeHtml(cause)}</span></div>
+    <div class="diag-row info"><span class="icon">i</span><span class="name">Host message</span><span class="detail">${escapeHtml(error)}</span></div>
+    <div class="diag-row ok"><span class="icon">→</span><span class="name">Fix on this PC</span><span class="detail">${escapeHtml(fix)}</span></div>
+    <div class="diag-row info"><span class="icon">i</span><span class="name">Extension ID</span><span class="detail">${escapeHtml(extensionId)}</span></div>
+    <div class="diag-row info"><span class="icon">1</span><span class="name">Run register-host</span><span class="detail">
+      <details open><summary>${escapeHtml(registerCommand)}</summary><pre>${escapeHtml(`Run ${registerCommand}\nWhen it asks for the extension ID, enter:\n${extensionId}\n\nPowerShell alternative:\n${installCommand}`)}</pre></details>
+      <span class="diag-action"><button type="button" data-copy="${escapeHtml(registerCommand)}" data-copy-label="Copy Script Path">Copy Script Path</button><button type="button" data-copy="${escapeHtml(extensionId)}" data-copy-label="Copy Extension ID">Copy Extension ID</button><button type="button" data-copy="${escapeHtml(installCommand)}" data-copy-label="Copy PowerShell Alternative">Copy PowerShell Alternative</button></span>
+    </span></div>
+    <div class="diag-row info"><span class="icon">2</span><span class="name">Restart Brave</span><span class="detail">Close every Brave window/process, reopen Brave, then reload the extension.</span></div>
+    <div class="diag-row info"><span class="icon">3</span><span class="name">Verify</span><span class="detail"><span class="diag-action"><button type="button" data-verify-registration>Verify Registration</button></span></span></div>
+  `;
+  for (const btn of out.querySelectorAll("button[data-copy]")) {
+    btn.addEventListener("click", async () => {
+      await navigator.clipboard.writeText(btn.dataset.copy || "");
+      btn.textContent = "Copied";
+      setTimeout(() => { btn.textContent = btn.dataset.copyLabel || "Copy"; }, 1200);
+    });
+  }
+  for (const btn of out.querySelectorAll("button[data-verify-registration]")) {
+    btn.addEventListener("click", runHostStatus);
+  }
+}
+
+function escapeHtml(s) {
+  return String(s).replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
+}
+
+// ---------- profiles ----------
+
+let _knownRemotes = [];  // ["cq:", "gdrive:", ...] from rclone listremotes
+let _cfgDefaults = { source: [], target: [] };
+let _remotesLoaded = false;
+
+async function fetchRemotes() {
+  const status = document.getElementById("profiles-status");
+  if (_remotesLoaded) return;
+  _remotesLoaded = true;
+  if (status) status.textContent = "loading remotes...";
+  try {
+    const r = await chrome.runtime.sendMessage({ type: "list-remotes" });
+    if (r && r.ok) {
+      _knownRemotes = r.remotes || [];
+      _cfgDefaults = { source: r.default_source || [], target: r.default_target || [] };
+      if (status) status.textContent = `${_knownRemotes.length} remote(s) loaded`;
+      // Re-render to populate selects now that we have data
+      const profiles = readProfiles();
+      renderProfiles(profiles);
+      updateSectionSummaries();
+    }
+  } catch (e) {
+    _remotesLoaded = false;
+    if (status) status.textContent = "failed to load remotes";
+  }
+}
+
+document.querySelector('.side .item[data-pane="profiles"]').addEventListener("click", fetchRemotes);
+document.getElementById("load-remotes").addEventListener("click", () => {
+  _remotesLoaded = false;
+  fetchRemotes();
+});
+
+/**
+ * Build a remote picker widget.
+ * Shows: a <select> dropdown of known remotes + an editable path suffix input +
+ * an Add button. Added remotes appear as chips below with × to remove.
+ * Falls back gracefully to a plain text input if no remotes loaded yet.
+ */
+function buildRemotePicker(container, values) {
+  container.innerHTML = "";
+
+  // --- selected list ---
+  const selectedList = document.createElement("div");
+  selectedList.className = "prof-selected-list";
+  selectedList.style.cssText = "margin-bottom:6px;";
+  container.appendChild(selectedList);
+
+  function addChip(path) {
+    const chip = document.createElement("div");
+    chip.className = "prof-chip";
+    chip.style.cssText = "display:flex;align-items:center;gap:6px;margin-bottom:4px;";
+    // Editable path so user can adjust subpath after picking
+    const inp = document.createElement("input");
+    inp.type = "text";
+    inp.value = path;
+    inp.className = "prof-chip-input";
+    inp.style.cssText = "flex:1;font-family:Consolas,monospace;font-size:12px;";
+    const rm = document.createElement("button");
+    rm.type = "button";
+    rm.textContent = "×";
+    rm.title = "Remove";
+    rm.style.cssText = "background:#511;border:1px solid #722;color:#faa;border-radius:3px;padding:0 7px;cursor:pointer;font-size:14px;line-height:1;";
+    rm.addEventListener("click", () => chip.remove());
+    chip.appendChild(inp);
+    chip.appendChild(rm);
+    selectedList.appendChild(chip);
+  }
+
+  // Pre-populate with existing values
+  for (const v of (values || [])) addChip(v);
+
+  // --- add row: select + optional subpath + Add button ---
+  const addRow = document.createElement("div");
+  addRow.style.cssText = "display:flex;gap:6px;align-items:center;flex-wrap:wrap;";
+
+  const sel = document.createElement("select");
+  sel.style.cssText = "background:#0d0d0d;color:#ddd;border:1px solid #2a2a2a;border-radius:4px;padding:5px 8px;font-family:Consolas,monospace;font-size:12px;min-width:130px;";
+  if (_knownRemotes.length) {
+    for (const r of _knownRemotes) {
+      const opt = document.createElement("option");
+      opt.value = r;
+      opt.textContent = r;
+      sel.appendChild(opt);
+    }
+  } else {
+    const opt = document.createElement("option");
+    opt.value = "";
+    opt.textContent = "(loading…)";
+    sel.appendChild(opt);
+  }
+
+  const subpathInp = document.createElement("input");
+  subpathInp.type = "text";
+  subpathInp.placeholder = "optional/subpath";
+  subpathInp.style.cssText = "flex:1;min-width:120px;font-family:Consolas,monospace;font-size:12px;";
+  subpathInp.title = "Append a subpath to narrow the remote, e.g. JAV/ClearJAV";
+
+  const addBtn = document.createElement("button");
+  addBtn.type = "button";
+  addBtn.textContent = "+ Add";
+  addBtn.style.cssText = "padding:5px 12px;font-size:12px;white-space:nowrap;";
+  addBtn.addEventListener("click", () => {
+    const base = sel.value.trim();
+    if (!base) return;
+    const sub = subpathInp.value.trim().replace(/^\//, "");
+    const full = sub ? base + sub : base;
+    addChip(full);
+    subpathInp.value = "";
+  });
+
+  // Also allow typing a fully custom path
+  const customInp = document.createElement("input");
+  customInp.type = "text";
+  customInp.placeholder = "or type full path (e.g. cq:JAV/ClearJAV)";
+  customInp.style.cssText = "flex:1;min-width:160px;font-family:Consolas,monospace;font-size:12px;margin-top:4px;";
+  const customBtn = document.createElement("button");
+  customBtn.type = "button";
+  customBtn.textContent = "+ Add";
+  customBtn.style.cssText = "padding:5px 12px;font-size:12px;margin-top:4px;white-space:nowrap;";
+  customBtn.addEventListener("click", () => {
+    const v = customInp.value.trim();
+    if (v) { addChip(v); customInp.value = ""; }
+  });
+  customInp.addEventListener("keydown", (e) => { if (e.key === "Enter") { e.preventDefault(); customBtn.click(); } });
+
+  addRow.appendChild(sel);
+  addRow.appendChild(subpathInp);
+  addRow.appendChild(addBtn);
+  container.appendChild(addRow);
+
+  const customRow = document.createElement("div");
+  customRow.style.cssText = "display:flex;gap:6px;align-items:center;flex-wrap:wrap;margin-top:4px;";
+  customRow.appendChild(customInp);
+  customRow.appendChild(customBtn);
+  container.appendChild(customRow);
+}
+
+function readRemoteGroup(container) {
+  return [...container.querySelectorAll(".prof-chip-input")]
+    .map(i => i.value.trim()).filter(Boolean);
+}
+
+function describeProfileRoots(label, values, defaults) {
+  const roots = (values || []).filter(Boolean);
+  if (roots.length) return `${label}: ${roots.join(", ")}`;
+  if ((defaults || []).length) return `${label}: config default ${defaults.join(", ")}`;
+  return `${label}: config.json default`;
+}
+
+function cloneProfile(profile) {
+  return {
+    name: (profile?.name || "").trim(),
+    source: [...(profile?.source || [])].filter(Boolean),
+    target: [...(profile?.target || [])].filter(Boolean),
+  };
+}
+
+function buildProfileRow(profile) {
+  const p = cloneProfile(profile);
+  const row = document.createElement("div");
+  row.className = "profile-card prof-row";
+  row._profile = p;
+  const detail = document.createElement("div");
+  detail.innerHTML = `
+    <div class="name">${escapeHtml(p.name)}</div>
+    <div class="roots">${escapeHtml(describeProfileRoots("Source", p.source, _cfgDefaults.source))}<br>${escapeHtml(describeProfileRoots("Target", p.target, _cfgDefaults.target))}</div>
+  `;
+  const actions = document.createElement("div");
+  actions.className = "actions";
+  const editBtn = document.createElement("button");
+  editBtn.type = "button";
+  editBtn.textContent = "Edit";
+  editBtn.addEventListener("click", () => openProfileModal(row));
+  const delBtn = document.createElement("button");
+  delBtn.type = "button";
+  delBtn.className = "danger";
+  delBtn.textContent = "Remove";
+  delBtn.addEventListener("click", () => {
+    row.remove();
+    updateSectionSummaries();
+  });
+  actions.appendChild(editBtn);
+  actions.appendChild(delBtn);
+  row.appendChild(detail);
+  row.appendChild(actions);
+  return row;
+}
+
+function renderProfiles(profiles) {
+  const list = document.getElementById("profiles-list");
+  list.innerHTML = "";
+  if (!profiles.length) {
+    const msg = document.createElement("div");
+    msg.style.cssText = "color:#666;font-size:12px;font-style:italic;margin-bottom:8px;";
+    msg.textContent = "No profiles defined. Searches use rc-jav's config.json defaults.";
+    list.appendChild(msg);
+    return;
+  }
+  for (const p of profiles) list.appendChild(buildProfileRow(p));
+}
+
+function readProfiles() {
+  return [...document.querySelectorAll("#profiles-list .prof-row")]
+    .map((row) => cloneProfile(row._profile))
+    .filter((profile) => profile.name);
+}
+
+let editingProfileRow = null;
+
+function setProfileModalDefaultsNote() {
+  const src = _cfgDefaults.source.length ? _cfgDefaults.source.join(", ") : "config.json default_source";
+  const tgt = _cfgDefaults.target.length ? _cfgDefaults.target.join(", ") : "config.json default_target";
+  document.getElementById("profile-modal-status").textContent = `Empty remote lists inherit source ${src} and target ${tgt}.`;
+}
+
+async function openProfileModal(row = null) {
+  editingProfileRow = row;
+  await fetchRemotes();
+  const profile = cloneProfile(row?._profile);
+  document.getElementById("profile-modal-title").textContent = row ? "Edit Library Profile" : "Add Library Profile";
+  document.getElementById("profile-modal-name").value = profile.name;
+  buildRemotePicker(document.getElementById("profile-modal-source"), profile.source);
+  buildRemotePicker(document.getElementById("profile-modal-target"), profile.target);
+  setProfileModalDefaultsNote();
+  openModal("profile-modal");
+  document.getElementById("profile-modal-name").focus();
+}
+
+function closeProfileModal() {
+  editingProfileRow = null;
+  closeModal("profile-modal");
+}
+
+document.getElementById("add-profile").addEventListener("click", () => openProfileModal());
+document.getElementById("profile-modal-save").addEventListener("click", () => {
+  const name = document.getElementById("profile-modal-name").value.trim();
+  const status = document.getElementById("profile-modal-status");
+  if (!name) {
+    status.textContent = "Profile name is required.";
+    return;
+  }
+  const profile = {
+    name,
+    source: readRemoteGroup(document.getElementById("profile-modal-source")),
+    target: readRemoteGroup(document.getElementById("profile-modal-target")),
+  };
+  const list = document.getElementById("profiles-list");
+  if (editingProfileRow) {
+    editingProfileRow.replaceWith(buildProfileRow(profile));
+  } else {
+    list.querySelector("div[style*='italic']")?.remove();
+    list.appendChild(buildProfileRow(profile));
+  }
+  closeProfileModal();
+  updateSectionSummaries();
+});
+for (const id of ["profile-modal-close", "profile-modal-cancel"]) {
+  document.getElementById(id).addEventListener("click", closeProfileModal);
+}
+document.getElementById("profile-modal").addEventListener("click", (event) => {
+  if (event.target.id === "profile-modal") closeProfileModal();
+});
+
+// ---------- paths ----------
+
+document.getElementById("clear-rcjav-path").addEventListener("click", () => {
+  document.getElementById("rcjavPath").value = "";
+  document.getElementById("path-check-output").textContent = "using host default";
+  updateSectionSummaries();
+});
+
+document.getElementById("check-rcjav-path").addEventListener("click", async () => {
+  const out = document.getElementById("path-check-output");
+  out.textContent = "checking...";
+  chrome.runtime.sendMessage({ type: "ping-host", rcjavPath: document.getElementById("rcjavPath").value.trim() }, (r) => {
+    if (chrome.runtime.lastError) {
+      out.textContent = chrome.runtime.lastError.message;
+      return;
+    }
+    if (!r || !r.ok) {
+      out.textContent = r?.error || "no response";
+      return;
+    }
+    out.textContent = r.rc_jav_exists ? `ok: ${r.rc_jav}` : `not found: ${r.rc_jav}`;
+    updateSectionSummaries();
+  });
+});
+
+(async () => {
+  const { optionsActivePane, pendingNativeSetupIssue } = await chrome.storage.local.get(["optionsActivePane", "pendingNativeSetupIssue"]);
+  activatePane(optionsActivePane || "triggers");
+  await load();
+  if (pendingNativeSetupIssue) {
+    activatePane("diagnostics");
+    await renderNativeMessagingFailure(pendingNativeSetupIssue);
+    await chrome.storage.local.remove("pendingNativeSetupIssue");
+  }
+  refreshActivity();
+})();
diff --git a/popup.css b/popup.css
new file mode 100644
index 0000000..c074338
--- /dev/null
+++ b/popup.css
@@ -0,0 +1,191 @@
+body { font-family: -apple-system, Segoe UI, sans-serif; font-size: 13px; width: 420px; margin: 0; padding: 8px; background: #1a1a1a; color: #ddd; }
+#header { display: flex; justify-content: space-between; align-items: center; margin-bottom: 6px; }
+#search-bar { display: flex; gap: 4px; margin-bottom: 6px; }
+#search-bar input { flex: 1; background: #0d0d0d; color: #ddd; border: 1px solid #444; border-radius: 3px; padding: 4px 8px; font-size: 12px; font-family: Consolas, monospace; box-sizing: border-box; min-width: 0; }
+#search-bar input:focus { outline: none; border-color: #6ec1ff; }
+#search-bar button { padding: 3px 8px; font-size: 12px; }
+#header strong { font-size: 14px; }
+#header-controls { display: flex; align-items: center; gap: 6px; }
+#mode-toggle { display: flex; border: 1px solid #444; border-radius: 3px; overflow: hidden; background: #181818; }
+#mode-toggle button {
+  border: 0;
+  border-right: 1px solid #444;
+  border-radius: 0;
+  background: #222;
+  color: #888;
+  padding: 3px 7px;
+  width: 48px;
+  font-size: 10px;
+  font-weight: 700;
+  letter-spacing: 0.4px;
+  text-align: center;
+}
+#mode-toggle button:last-child { border-right: 0; }
+#mode-toggle button:hover { background: #2a2a2a; color: #ddd; }
+#mode-toggle button.active {
+  background: #1a2a3a;
+  color: #6ec1ff;
+}
+#mode-toggle button.active[data-mode="cache"] {
+  background: #1a3a1a;
+  color: #afa;
+}
+#pause-scan {
+  width: 28px;
+  height: 24px;
+  padding: 0;
+  font-size: 12px;
+  line-height: 22px;
+}
+#pause-scan.paused {
+  background: #3a2f13;
+  border-color: #66551f;
+  color: #ffdd77;
+}
+button { background: #333; color: #ddd; border: 1px solid #555; border-radius: 3px; padding: 3px 8px; cursor: pointer; font-size: 12px; }
+button:hover { background: #444; }
+button.scanning { background: #3a1a1a; border-color: #722; color: #faa; }
+button.scanning:hover { background: #4a1a1a; }
+#status { padding: 8px 10px; border-radius: 3px; background: #222; margin-bottom: 6px; font-size: 13px; display: flex; align-items: center; gap: 8px; }
+#status.hit { background: #1e3a1e; color: #afa; }
+#status.miss { background: #3a1e1e; color: #faa; }
+#status.err { background: #3a3a1e; color: #ffa; }
+#status.loading { background: #1a2a3a; color: #6ec1ff; }
+#status .spinner {
+  width: 14px; height: 14px; border-radius: 50%;
+  border: 2px solid rgba(110, 193, 255, 0.25);
+  border-top-color: #6ec1ff;
+  animation: spin 0.7s linear infinite;
+  flex-shrink: 0;
+}
+@keyframes spin { to { transform: rotate(360deg); } }
+@keyframes pulse { 0%, 100% { opacity: 0.5; } 50% { opacity: 0.9; } }
+#output .skeleton {
+  background: #161616;
+  border: 1px solid #2a2a2a;
+  border-radius: 4px;
+  padding: 10px;
+  margin-bottom: 6px;
+  animation: pulse 1.2s ease-in-out infinite;
+}
+#output .skeleton .bar { height: 10px; background: #2a2a2a; border-radius: 2px; margin: 4px 0; }
+#output .skeleton .bar.short { width: 50%; }
+#output .skeleton .bar.long { width: 90%; }
+#output .skeleton .bar.tiny { width: 30%; height: 8px; }
+#output { background: #0d0d0d; padding: 6px; border-radius: 3px; margin: 0; color: #bbb; }
+#output:empty { display: none; }
+#output .hit { background: #161616; border: 1px solid #2a2a2a; border-radius: 4px; padding: 10px; margin-bottom: 6px; }
+#output > *:last-child, #output .hit:last-child { margin-bottom: 0; }
+#output .hit > *:first-child { margin-top: 0; }
+#output .hit > *:last-child { margin-bottom: 0; }
+#output .hit .file { color: #fff; font-weight: 600; font-size: 13px; word-break: break-all; margin: 0 0 4px; }
+#output .hit .path { color: #aaa; font-size: 13px; font-family: Consolas, monospace; word-break: break-all; margin: 0 0 6px; line-height: 1.45; }
+#output .hit .plabel { color: #555; font-weight: 600; }
+#output .hit .meta { display: flex; align-items: center; gap: 8px; font-size: 11px; line-height: 1; }
+#output .hit .size { color: #6ec1ff; font-weight: 600; }
+#output .hit .src { background: #2a2a1a; color: #ffcc44; padding: 1px 6px; border-radius: 10px; font-size: 10px; font-weight: 600; letter-spacing: 0.3px; }
+#output .hit .src.source { background: #1a3a1a; color: #66dd66; }
+#output .hit .src.catalog { background: #1a2a3a; color: #66bbff; }
+#output .hit .reason { background: #202a32; color: #9dccff; border: 1px solid #314453; padding: 1px 6px; border-radius: 10px; font-size: 10px; font-weight: 600; }
+#output .empty { color: #888; font-style: italic; padding: 6px; }
+#output .no-match-detail { font-style: normal; line-height: 1.45; background:#17170f; border:1px solid #3d3a1f; border-radius:4px; margin-bottom:6px; color:#bcb58a; }
+#output .no-match-detail strong { display:block; color:#ffe08a; font-size:11px; margin-bottom:2px; }
+#output .err { color: #faa; font-family: Consolas, monospace; white-space: pre-wrap; padding: 4px; }
+#output .setup-guide { background:#17170f; border:1px solid #4a4420; border-radius:4px; color:#ffdd77; padding:9px; line-height:1.45; margin-bottom:6px; }
+#output .setup-guide strong { display:block; color:#fff0a5; margin-bottom:3px; }
+#output .setup-guide .detail { color:#bcb58a; font-size:11px; }
+#output .setup-guide .actions { display:flex; gap:6px; margin-top:7px; }
+#output .setup-guide button { font-size:11px; padding:3px 7px; }
+#output .timings {
+  color: #777;
+  font-family: Consolas, monospace;
+  font-size: 10px;
+  padding: 4px 2px 0;
+}
+.timing-strip {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 6px;
+  margin-top: 6px;
+  padding: 7px 6px;
+  background: #111;
+  border: 1px solid #262626;
+  border-radius: 4px;
+}
+.timing-metric {
+  min-width: 0;
+  text-align: center;
+}
+.timing-label {
+  color: #666;
+  font-size: 9px;
+  font-weight: 700;
+  letter-spacing: 0.5px;
+  line-height: 1.2;
+}
+.timing-value {
+  color: #aaa;
+  font-family: Consolas, monospace;
+  font-size: 11px;
+  line-height: 1.35;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+#filter-bar { display: flex; gap: 4px; margin-bottom: 4px; flex-wrap: wrap; }
+.filter-chip { background: #1e1e1e; border: 1px solid #444; color: #aaa; border-radius: 10px; padding: 2px 8px; font-size: 11px; cursor: pointer; }
+.filter-chip:hover { background: #2a2a2a; }
+.filter-chip.active { background: #1a2a3a; border-color: #6ec1ff; color: #6ec1ff; }
+#history-bar { display: flex; align-items: flex-start; gap: 4px; margin-bottom: 6px; }
+#history-chips { display: flex; flex-wrap: wrap; gap: 4px; flex: 1; min-width: 0; }
+.history-chip { background: #1a1a2a; border: 1px solid #334; color: #88aaff; border-radius: 10px; padding: 2px 8px; font-size: 11px; font-family: Consolas, monospace; cursor: pointer; white-space: nowrap; }
+.history-chip:hover { background: #22223a; border-color: #557; }
+#history-clear { background: none; border: none; color: #555; font-size: 13px; cursor: pointer; padding: 2px 4px; flex-shrink: 0; }
+#history-clear:hover { color: #aaa; }
+#cache-banner { background: #2a2500; border: 1px solid #554400; color: #ffcc44; font-size: 11px; padding: 4px 8px; border-radius: 3px; margin-bottom: 6px; line-height: 1.45; }
+#cache-banner.no-cache { background: #1a1a2a; border-color: #334; color: #88aaff; }
+#actions { margin-top: 8px; display: flex; gap: 6px; align-items: center; }
+#actions #ping { margin-left: auto; }
+#actions #delete-btn { margin-left: auto; }
+
+/* Modal row — same look as result cards */
+#modal-list .hit {
+  background: #161616;
+  border: 1px solid #2a2a2a;
+  border-radius: 4px;
+  padding: 10px;
+  margin-bottom: 6px;
+  cursor: pointer;
+  transition: background 0.1s, border-color 0.1s;
+}
+#modal-list .hit:last-child { margin-bottom: 0; }
+#modal-list .hit:hover { background: #1e1e1e; border-color: #444; }
+#modal-list .hit.selected { background: #3a1e1e; border-color: #722; }
+#modal-list .hit .file { color: #fff; font-weight: 600; font-size: 13px; word-break: break-all; margin: 0 0 4px; }
+#modal-list .hit .path { color: #aaa; font-size: 13px; font-family: Consolas, monospace; word-break: break-all; margin: 0 0 6px; line-height: 1.45; }
+#modal-list .hit .plabel { color: #555; font-weight: 600; }
+#modal-list .hit .meta { display: flex; align-items: center; gap: 8px; font-size: 11px; line-height: 1; }
+#modal-list .hit .size { color: #6ec1ff; font-weight: 600; }
+#modal-list .hit .src { background: #2a2a1a; color: #ffcc44; padding: 1px 6px; border-radius: 10px; font-size: 10px; font-weight: 600; letter-spacing: 0.3px; }
+#modal-list .hit .src.source { background: #1a3a1a; color: #66dd66; }
+#modal-list .hit .src.catalog { background: #1a2a3a; color: #66bbff; }
+#status:not(.loading) + #output:empty + #actions,
+#status + #output:empty + #actions { margin-top: 0; }
+
+/* Undo modal entries */
+#undo-list .undo-entry {
+  background: #161616;
+  border: 1px solid #2a2a2a;
+  border-radius: 4px;
+  padding: 10px;
+  margin-bottom: 6px;
+}
+#undo-list .undo-entry:last-child { margin-bottom: 0; }
+#undo-list .undo-entry .file { color: #fff; font-weight: 600; font-size: 13px; word-break: break-all; margin: 0 0 4px; }
+#undo-list .undo-entry .path { color: #aaa; font-size: 11px; font-family: Consolas, monospace; word-break: break-all; margin: 0 0 3px; line-height: 1.4; }
+#undo-list .undo-entry .plabel { color: #555; font-weight: 600; }
+#undo-list .undo-meta { display: flex; align-items: center; justify-content: space-between; margin-top: 4px; }
+#undo-list .undo-age { color: #777; font-size: 10px; }
+#undo-list .undo-row-btn { background: #1a2a1a; border: 1px solid #3a5a3a; color: #66dd66; border-radius: 3px; padding: 2px 8px; font-size: 11px; cursor: pointer; }
+#undo-list .undo-row-btn:hover { background: #243a24; }
+#undo-list .undo-row-btn:disabled { opacity: 0.5; cursor: default; }
diff --git a/popup.html b/popup.html
new file mode 100644
index 0000000..ff6ac97
--- /dev/null
+++ b/popup.html
@@ -0,0 +1,74 @@
+<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <link rel="stylesheet" href="popup.css">
+</head>
+<body>
+  <div id="header">
+    <strong>rclone-jav</strong>
+    <select id="profile-select" title="Active library profile" style="display:none;background:#222;color:#ddd;border:1px solid #444;border-radius:3px;font-size:12px;padding:2px 4px;max-width:140px;"></select>
+    <div id="header-controls">
+      <div id="mode-toggle" title="Search mode">
+        <button id="mode-live" type="button" data-mode="live" title="LIVE: query rclone directly">LIVE</button>
+        <button id="mode-cache" type="button" data-mode="cache" title="CACHE: use cache.json">CACHE</button>
+      </div>
+      <button id="pause-scan" type="button" title="Pause scanning">⏸</button>
+      <button id="open-options" title="Options">⚙</button>
+    </div>
+  </div>
+  <div id="search-bar">
+    <input id="search-input" type="text" placeholder="search ID (e.g. SSIS-001, PRTD-[1-10])" spellcheck="false" autocomplete="off">
+    <button id="search-go" title="Search">🔍</button>
+    <button id="search-clear" title="Clear / back to current tab">×</button>
+  </div>
+  <div id="history-bar" style="display:none;">
+    <div id="history-chips"></div>
+    <button id="history-clear" title="Clear search history">✕</button>
+  </div>
+  <div id="cache-banner" style="display:none;"></div>
+  <div id="status">checking…</div>
+  <div id="filter-bar" style="display:none;"></div>
+  <div id="output"></div>
+  <div id="actions">
+    <button id="recheck">Re-Scan</button>
+    <button id="ping">Ping Host</button>
+    <button id="undo-btn" title="Undo recent trash delete" style="display:none;">↶ Undo</button>
+    <button id="delete-btn" style="display:none;background:#511;border-color:#722;color:#faa;font-weight:600;letter-spacing:0.5px;">DELETE</button>
+  </div>
+
+  <!-- Delete modal -->
+  <div id="modal-overlay" style="display:none;position:fixed;inset:0;background:rgba(0,0,0,.8);z-index:100;overflow-y:auto;">
+    <div id="modal" style="background:#1a1a1a;border:1px solid #722;border-radius:6px;padding:10px;margin:8px;color:#ddd;font-size:12px;">
+      <h3 style="margin:0 0 8px;color:#faa;font-size:13px;">Choose file to delete</h3>
+      <div id="modal-list" style="padding:6px;background:#0d0d0d;border-radius:3px;"></div>
+      <div id="modal-confirm" style="display:none;margin-top:8px;">
+        <div id="modal-target" style="background:#0d0d0d;padding:4px 6px;font-size:10px;font-family:Consolas,monospace;border:1px solid #444;border-radius:3px;margin-bottom:6px;word-break:break-all;"></div>
+        <div style="margin-bottom:4px;">Type the exact filename to confirm:</div>
+        <div id="confirm-id" style="color:#faa;font-family:Consolas,monospace;word-break:break-all;font-size:10px;background:#0d0d0d;padding:4px 6px;border:1px solid #444;border-radius:3px;margin-bottom:4px;"></div>
+        <input id="modal-confirm-input" style="width:100%;background:#0d0d0d;color:#ddd;border:1px solid #722;padding:6px;font-family:Consolas,monospace;font-size:11px;box-sizing:border-box;">
+        <div id="modal-mode" style="font-size:10px;color:#aaa;margin-top:4px;"></div>
+      </div>
+      <div style="display:flex;justify-content:flex-end;gap:6px;margin-top:8px;">
+        <button id="modal-cancel">Cancel</button>
+        <button id="modal-delete" disabled style="background:#511;border-color:#722;color:#faa;font-weight:600;letter-spacing:0.5px;">DELETE</button>
+      </div>
+      <div id="modal-status" style="font-size:10px;margin-top:4px;color:#aaa;"></div>
+    </div>
+  </div>
+
+  <!-- Undo modal -->
+  <div id="undo-overlay" style="display:none;position:fixed;inset:0;background:rgba(0,0,0,.8);z-index:100;overflow-y:auto;">
+    <div id="undo-modal" style="background:#1a1a1a;border:1px solid #555;border-radius:6px;padding:10px;margin:8px;color:#ddd;font-size:12px;">
+      <h3 style="margin:0 0 8px;color:#aaa;font-size:13px;">Recent trash deletes</h3>
+      <div id="undo-list" style="padding:6px;background:#0d0d0d;border-radius:3px;min-height:30px;"></div>
+      <div style="display:flex;justify-content:flex-end;margin-top:8px;">
+        <button id="undo-cancel">Close</button>
+      </div>
+      <div id="undo-status" style="font-size:10px;margin-top:4px;color:#aaa;"></div>
+    </div>
+  </div>
+
+  <script src="popup.js"></script>
+</body>
+</html>
diff --git a/popup.js b/popup.js
new file mode 100644
index 0000000..aeff5cb
--- /dev/null
+++ b/popup.js
@@ -0,0 +1,659 @@
+const $status = document.getElementById("status");
+const $output = document.getElementById("output");
+const $deleteBtn = document.getElementById("delete-btn");
+const $undoBtn = document.getElementById("undo-btn");
+const $cacheBanner = document.getElementById("cache-banner");
+const $filterBar = document.getElementById("filter-bar");
+const $modeLive = document.getElementById("mode-live");
+const $modeCache = document.getElementById("mode-cache");
+const $pauseScan = document.getElementById("pause-scan");
+
+let lastResult = null;
+let settings = null;
+let activeFilter = "all"; // "all" | "Source" | "Target" | "Catalog"
+
+function syncModeToggle() {
+  const live = settings && settings.quickMode !== false;
+  $modeLive.classList.toggle("active", live);
+  $modeCache.classList.toggle("active", !live);
+  $modeLive.setAttribute("aria-pressed", live ? "true" : "false");
+  $modeCache.setAttribute("aria-pressed", !live ? "true" : "false");
+}
+
+function syncPauseButton() {
+  const paused = !!(settings && settings.scanPaused);
+  $pauseScan.classList.toggle("paused", paused);
+  $pauseScan.textContent = paused ? "▶" : "⏸";
+  $pauseScan.title = paused ? "Resume scanning" : "Pause scanning";
+  $pauseScan.setAttribute("aria-pressed", paused ? "true" : "false");
+}
+
+function renderPausedState() {
+  setStatus("Scanning paused", "err");
+  $output.innerHTML = "";
+  const div = document.createElement("div");
+  div.className = "empty";
+  div.textContent = "Press ▶ to resume scans.";
+  $output.appendChild(div);
+  $deleteBtn.style.display = "none";
+  $undoBtn.style.display = "none";
+}
+
+async function setScanPaused(paused) {
+  const s = await chrome.runtime.sendMessage({ type: "get-settings" }) || {};
+  settings = Object.assign({}, s, { scanPaused: paused });
+  await chrome.storage.sync.set({ settings });
+  chrome.runtime.sendMessage({ type: "settings-changed" });
+  syncPauseButton();
+  if (paused) renderPausedState();
+  else if (manualMode && $searchInput.value.trim()) runManualSearch();
+  else runCheck(true);
+}
+
+async function setSearchMode(mode) {
+  const quickMode = mode === "live";
+  if (settings && settings.quickMode === quickMode) return;
+  const s = await chrome.runtime.sendMessage({ type: "get-settings" }) || {};
+  settings = Object.assign({}, s, { quickMode });
+  await chrome.storage.sync.set({ settings });
+  chrome.runtime.sendMessage({ type: "settings-changed" });
+  syncModeToggle();
+  if (manualMode && $searchInput.value.trim()) runManualSearch();
+  else runCheck(true);
+}
+
+function setStatus(text, cls = "") {
+  $status.className = cls;
+  if (cls === "loading") {
+    $status.innerHTML = `<span class="spinner"></span><span>${text}</span>`;
+  } else {
+    $status.textContent = text;
+  }
+}
+
+function showSkeleton(rows = 2) {
+  $output.innerHTML = "";
+  for (let i = 0; i < rows; i++) {
+    const div = document.createElement("div");
+    div.className = "skeleton";
+    div.innerHTML = `
+      <div class="bar long"></div>
+      <div class="bar short"></div>
+      <div class="bar tiny"></div>
+    `;
+    $output.appendChild(div);
+  }
+}
+
+function fmtAge(ts) {
+  if (!ts) return "";
+  const s = Math.round((Date.now() - ts) / 1000);
+  if (s < 60) return `${s}s ago`;
+  if (s < 3600) return `${Math.round(s / 60)}m ago`;
+  return `${Math.round(s / 3600)}h ago`;
+}
+
+function escapeHtml(s) {
+  return String(s).replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
+}
+
+function fmtMs(n) {
+  return Number.isFinite(n) ? `${n}ms` : "?";
+}
+
+function renderTimings(r) {
+  const t = r && r.timings;
+  if (!t) return;
+  const div = document.createElement("div");
+  div.className = "timing-strip";
+  const engineLabel = Number.isFinite(t.host_cached_ms) ? "HOST" : "RC-JAV";
+  const engineMs = Number.isFinite(t.host_cached_ms) ? t.host_cached_ms : t.host_rcjav_ms;
+  const matchMs = t.cache_match_ms ?? t.match_ms;
+  const metrics = [
+    ["TOTAL", fmtMs(t.total_ms)],
+    [engineLabel, fmtMs(engineMs)],
+    ["EXTRACT", fmtMs(t.extract_ms)],
+    ["MATCH", fmtMs(matchMs)],
+  ];
+  div.innerHTML = metrics.map(([label, value]) => `
+    <div class="timing-metric">
+      <div class="timing-label">${escapeHtml(label)}</div>
+      <div class="timing-value">${escapeHtml(value)}</div>
+    </div>
+  `).join("");
+  $output.appendChild(div);
+}
+
+function renderSearchMode(_r) {
+  // Mode chip removed — the LIVE/CACHE toggle in the header already shows the mode.
+}
+
+function buildHitCard(h) {
+  const filename = h.path.split("/").pop();
+  const idx = h.full_path.lastIndexOf("/");
+  const dir = idx >= 0 ? h.full_path.slice(0, idx) : h.full_path;
+  const srcCls = h.source === "Source" ? "src source"
+               : h.source === "Catalog" ? "src catalog" : "src";
+  const confidence = h.match_confidence ? ` · ${h.match_confidence}` : "";
+  const reason = h.match_reason
+    ? `<span class="reason" title="Matched ${escapeHtml(h.matched_query || h.jav_id || "")}${escapeHtml(confidence)}">${escapeHtml(h.match_reason)}</span>`
+    : "";
+  const div = document.createElement("div");
+  div.className = "hit";
+  div.innerHTML = `
+    <div class="file">${escapeHtml(filename)}</div>
+    <div class="path"><span class="plabel">Path:</span> ${escapeHtml(dir)}</div>
+    <div class="meta"><span class="${srcCls}">${escapeHtml(h.source.toUpperCase())}</span><span class="size">${escapeHtml(h.size_human)}</span>${reason}</div>
+  `;
+  return div;
+}
+
+function renderFilterBar(structured) {
+  $filterBar.innerHTML = "";
+  if (!structured || structured.length < 2) { $filterBar.style.display = "none"; return; }
+  const sources = [...new Set(structured.map((h) => h.source))];
+  if (sources.length < 2) { $filterBar.style.display = "none"; return; }
+  $filterBar.style.display = "";
+  const filters = ["all", ...sources];
+  for (const f of filters) {
+    const chip = document.createElement("span");
+    chip.className = "filter-chip" + (activeFilter === f ? " active" : "");
+    chip.textContent = f === "all" ? "All" : f;
+    chip.addEventListener("click", () => {
+      activeFilter = f;
+      renderHits(lastResult && lastResult.structured);
+      for (const c of $filterBar.children) c.classList.toggle("active", c.textContent === (f === "all" ? "All" : f));
+    });
+    $filterBar.appendChild(chip);
+  }
+}
+
+function renderHits(structured) {
+  // Clear existing hit cards but keep mode/timing lines
+  for (const el of [...$output.children]) {
+    if (el.classList.contains("hit") || el.classList.contains("empty")) el.remove();
+  }
+  const hits = structured || [];
+  const filtered = activeFilter === "all" ? hits : hits.filter((h) => h.source === activeFilter);
+  if (filtered.length) {
+    const anchor = $output.querySelector(".timing-strip") || $output.querySelector(".timings");
+    for (const h of filtered) {
+      const card = buildHitCard(h);
+      if (anchor) $output.insertBefore(card, anchor);
+      else $output.appendChild(card);
+    }
+  } else {
+    const div = document.createElement("div");
+    div.className = "empty";
+    div.textContent = filtered.length === 0 && activeFilter !== "all"
+      ? `No ${activeFilter} results`
+      : "no matches";
+    const anchor = $output.querySelector(".timing-strip") || $output.querySelector(".timings");
+    if (anchor) $output.insertBefore(div, anchor);
+    else $output.appendChild(div);
+  }
+}
+
+function isNativeRegistrationIssue(result) {
+  return result && (result.error_kind === "forbidden" || result.error_kind === "not_found");
+}
+
+function renderNativeSetupGuide(result) {
+  const div = document.createElement("div");
+  div.className = "setup-guide";
+  const forbidden = result.error_kind === "forbidden";
+  div.innerHTML = `
+    <strong>${forbidden ? "Register this extension ID on this PC" : "Native host registration is missing on this PC"}</strong>
+    <div class="detail">${forbidden
+      ? "Brave found the host, but this copy of the extension is not allowed to launch it yet."
+      : "Brave cannot find the rclone-jav native host yet."}</div>
+    <div class="actions">
+      <button type="button" data-open-native-setup>Open Registration Guide</button>
+      ${result.extension_id ? `<button type="button" data-copy-extension-id="${escapeHtml(result.extension_id)}">Copy Extension ID</button>` : ""}
+    </div>
+  `;
+  div.querySelector("[data-open-native-setup]").addEventListener("click", async () => {
+    await chrome.storage.local.set({
+      optionsActivePane: "diagnostics",
+      pendingNativeSetupIssue: {
+        error: result.error || result.reason || "native host registration failed",
+        error_kind: result.error_kind,
+        extension_id: result.extension_id || "",
+      },
+    });
+    chrome.runtime.openOptionsPage();
+  });
+  const copy = div.querySelector("[data-copy-extension-id]");
+  if (copy) {
+    copy.addEventListener("click", async () => {
+      await navigator.clipboard.writeText(copy.dataset.copyExtensionId || "");
+      copy.textContent = "Copied";
+      setTimeout(() => { copy.textContent = "Copy Extension ID"; }, 1200);
+    });
+  }
+  $output.appendChild(div);
+}
+
+function renderResult(r) {
+  lastResult = r;
+  activeFilter = "all";
+  $output.innerHTML = "";
+  $filterBar.style.display = "none";
+  if (!r) { setStatus("no response", "err"); return; }
+  const tag = r.cached ? ` [session ${fmtAge(r.ts)}]` : "";
+  if (!r.ok) {
+    setStatus("✗ " + (r.reason || "error") + tag, "err");
+    $output.innerHTML = "";
+    if (r.no_match_title || r.no_match_detail) {
+      const div = document.createElement("div");
+      div.className = "empty no-match-detail";
+      div.innerHTML = `<strong>${escapeHtml(r.no_match_title || "No result")}</strong>${r.no_match_detail ? `<div>${escapeHtml(r.no_match_detail)}</div>` : ""}`;
+      $output.appendChild(div);
+    }
+    if (r.stderr || r.error) {
+      const div = document.createElement("div");
+      div.className = "err";
+      div.textContent = r.stderr || r.error;
+      $output.appendChild(div);
+    }
+    if (isNativeRegistrationIssue(r)) renderNativeSetupGuide(r);
+    $deleteBtn.style.display = "none";
+    $undoBtn.style.display = "none";
+    return;
+  }
+  const idShown = r.id || (r.structured && r.structured[0] && r.structured[0].jav_id) || "?";
+  if (r.hits > 0) setStatus(`✓ ${idShown} — ${r.hits} hit(s)${tag}`, "hit");
+  else setStatus(`✗ ${idShown} — NOT FOUND${tag}`, "miss");
+
+  // Render mode + timings first (renderHits inserts before these)
+  renderSearchMode(r);
+  renderTimings(r);
+  // Render filter bar then hit cards
+  renderFilterBar(r.structured);
+  if (r.structured && r.structured.length) {
+    renderHits(r.structured);
+  } else {
+    const div = document.createElement("div");
+    div.className = "empty no-match-detail";
+    div.innerHTML = `<strong>${escapeHtml(r.no_match_title || "No matches")}</strong>${r.no_match_detail ? `<div>${escapeHtml(r.no_match_detail)}</div>` : ""}`;
+    $output.insertBefore(div, $output.firstChild);
+  }
+
+  const canDelete = settings && settings.enableDelete && r.structured && r.structured.length > 1;
+  $deleteBtn.style.display = canDelete ? "" : "none";
+  $deleteBtn.textContent = "DELETE";
+  $undoBtn.style.display = (settings && settings.enableDelete && settings.deleteMode === "trash") ? "" : "none";
+}
+
+function runCheck(force = false) {
+  if (settings && settings.scanPaused) { renderPausedState(); return; }
+  setStatus("Scanning…", "loading");
+  showSkeleton(2);
+  $deleteBtn.style.display = "none";
+  $undoBtn.style.display = "none";
+  chrome.runtime.sendMessage({ type: "check-tab", force }, (r) => {
+    if (chrome.runtime.lastError) {
+      setStatus("error: " + chrome.runtime.lastError.message, "err");
+      $output.innerHTML = "";
+      return;
+    }
+    renderResult(r);
+  });
+}
+
+// ----- delete modal -----
+
+const $overlay = document.getElementById("modal-overlay");
+const $list = document.getElementById("modal-list");
+const $confirmWrap = document.getElementById("modal-confirm");
+const $target = document.getElementById("modal-target");
+const $confirmId = document.getElementById("confirm-id");
+const $confirmInput = document.getElementById("modal-confirm-input");
+const $mode = document.getElementById("modal-mode");
+const $modalDelete = document.getElementById("modal-delete");
+const $modalStatus = document.getElementById("modal-status");
+let chosenHit = null;
+let expectedId = "";
+
+function openDeleteModal() {
+  if (!lastResult || !lastResult.structured) return;
+  $list.innerHTML = "";
+  chosenHit = null;
+  $confirmWrap.style.display = "none";
+  $modalDelete.disabled = true;
+  $modalStatus.textContent = "";
+  $confirmInput.value = "";
+
+  for (const h of lastResult.structured) {
+    const filename = h.path.split("/").pop();
+    const idx = h.full_path.lastIndexOf("/");
+    const dir = idx >= 0 ? h.full_path.slice(0, idx) : h.full_path;
+    const srcCls = h.source === "Source" ? "src source"
+                 : h.source === "Catalog" ? "src catalog" : "src";
+    const row = document.createElement("div");
+    row.className = "hit";
+    row.innerHTML = `
+      <div class="file">${escapeHtml(filename)}</div>
+      <div class="path"><span class="plabel">Path:</span> ${escapeHtml(dir)}</div>
+      <div class="meta"><span class="${srcCls}">${escapeHtml(h.source.toUpperCase())}</span><span class="size">${escapeHtml(h.size_human)}</span></div>
+    `;
+    row.addEventListener("click", () => selectHit(h, row));
+    $list.appendChild(row);
+  }
+  $overlay.style.display = "block";
+}
+
+function selectHit(h, row) {
+  chosenHit = h;
+  for (const el of $list.children) el.classList.remove("selected");
+  row.classList.add("selected");
+  $confirmWrap.style.display = "";
+  $target.textContent = h.full_path;
+  // Require typing the full filename (basename incl. extension) — strongest unique signal.
+  expectedId = h.path.split("/").pop();
+  $confirmId.textContent = expectedId;
+  const modeText = settings.deleteMode === "permanent"
+    ? "PERMANENTLY DELETE"
+    : `move to trash: ${settings.trashDir}`;
+  $mode.innerHTML = `
+    <div><strong>Mode:</strong> ${escapeHtml(modeText)}</div>
+    <div><strong>Source:</strong> ${escapeHtml(h.source || "?")}</div>
+    <div><strong>Remote/prefix:</strong> ${escapeHtml(h.remote || "?")}</div>
+    <div><strong>Host safety:</strong> path must be inside configured rc-jav source/target or trash prefixes.</div>
+  `;
+  $confirmInput.value = "";
+  $confirmInput.focus();
+  $modalDelete.disabled = true;
+}
+
+$confirmInput.addEventListener("input", () => {
+  // Case-insensitive, exact filename match.
+  $modalDelete.disabled = $confirmInput.value.trim().toLowerCase() !== expectedId.toLowerCase();
+});
+
+document.getElementById("modal-cancel").addEventListener("click", () => {
+  $overlay.style.display = "none";
+});
+
+$modalDelete.addEventListener("click", () => {
+  if (!chosenHit) return;
+  $modalDelete.disabled = true;
+  $modalStatus.textContent = "deleting…";
+  chrome.runtime.sendMessage({ type: "delete-file", path: chosenHit.full_path }, (r) => {
+    if (!r) { $modalStatus.textContent = "no response"; return; }
+    if (!r.ok) { $modalStatus.textContent = "error: " + (r.error || r.stderr || "unknown"); return; }
+    $modalStatus.textContent = (settings.deleteMode === "permanent" ? "deleted" : "moved to: " + r.dst);
+    // Refresh underlying tab result
+    setTimeout(() => {
+      $overlay.style.display = "none";
+      runCheck(true);
+    }, 800);
+  });
+});
+
+// ----- search history -----
+
+const HISTORY_KEY = "searchHistory";
+const HISTORY_MAX = 20;
+const $historyBar = document.getElementById("history-bar");
+const $historyChips = document.getElementById("history-chips");
+
+async function loadHistory() {
+  const got = await chrome.storage.local.get(HISTORY_KEY);
+  return Array.isArray(got[HISTORY_KEY]) ? got[HISTORY_KEY] : [];
+}
+
+async function pushHistory(id) {
+  const list = await loadHistory();
+  const filtered = list.filter((x) => x.toLowerCase() !== id.toLowerCase());
+  const updated = [id, ...filtered].slice(0, HISTORY_MAX);
+  await chrome.storage.local.set({ [HISTORY_KEY]: updated });
+  renderHistory(updated);
+}
+
+function renderHistory(list) {
+  $historyChips.innerHTML = "";
+  if (!list || !list.length) { $historyBar.style.display = "none"; return; }
+  $historyBar.style.display = "";
+  for (const id of list) {
+    const chip = document.createElement("span");
+    chip.className = "history-chip";
+    chip.textContent = id;
+    chip.title = `Search ${id}`;
+    chip.addEventListener("click", () => {
+      $searchInput.value = id;
+      runManualSearch();
+    });
+    $historyChips.appendChild(chip);
+  }
+}
+
+document.getElementById("history-clear").addEventListener("click", async () => {
+  await chrome.storage.local.set({ [HISTORY_KEY]: [] });
+  renderHistory([]);
+});
+
+// ----- manual search -----
+
+const $searchInput = document.getElementById("search-input");
+const $searchGo = document.getElementById("search-go");
+const $searchClear = document.getElementById("search-clear");
+let manualMode = false; // true while popup is showing manual-search results
+
+function runManualSearch() {
+  const raw = $searchInput.value.trim();
+  if (!raw) return;
+  if (settings && settings.scanPaused) { renderPausedState(); return; }
+  manualMode = true;
+  setStatus(`Searching ${raw}…`, "loading");
+  showSkeleton(2);
+  $deleteBtn.style.display = "none";
+  $undoBtn.style.display = "none";
+  const t0 = performance.now();
+  chrome.runtime.sendMessage({
+    type: "manual-query",
+    action: "search",
+    id: raw,
+    quick: !!(settings && settings.quickMode),
+  }, (r) => {
+    if (chrome.runtime.lastError) {
+      setStatus("error: " + chrome.runtime.lastError.message, "err");
+      $output.innerHTML = "";
+      return;
+    }
+    // The host search response uses the same shape as check-tab, so reuse the
+    // renderer. Synthesize a `timings.total_ms` so the timing chip still works.
+    const result = Object.assign({}, r, {
+      id: raw,
+      timings: Object.assign({ total_ms: Math.round(performance.now() - t0) }, r && r.timings ? r.timings : {}),
+    });
+    renderResult(result);
+    if (result && result.ok) pushHistory(raw);
+  });
+}
+
+$searchGo.addEventListener("click", runManualSearch);
+$searchInput.addEventListener("keydown", (e) => {
+  if (e.key === "Enter") { e.preventDefault(); runManualSearch(); }
+});
+$searchClear.addEventListener("click", () => {
+  $searchInput.value = "";
+  manualMode = false;
+  runCheck(false);
+  $searchInput.focus();
+});
+
+// ----- undo modal -----
+
+const $undoOverlay = document.getElementById("undo-overlay");
+const $undoList = document.getElementById("undo-list");
+const $undoStatus = document.getElementById("undo-status");
+
+function openUndoModal() {
+  $undoList.innerHTML = `<div class="empty">Loading…</div>`;
+  $undoStatus.textContent = "";
+  $undoOverlay.style.display = "block";
+  chrome.runtime.sendMessage({ type: "recent-deletes", limit: 20 }, (r) => {
+    if (chrome.runtime.lastError) {
+      $undoList.innerHTML = `<div class="err">${escapeHtml(chrome.runtime.lastError.message)}</div>`;
+      return;
+    }
+    if (!r || !r.ok) {
+      $undoList.innerHTML = `<div class="err">${escapeHtml((r && r.error) || "unknown error")}</div>`;
+      return;
+    }
+    const entries = (r.entries || []);
+    if (!entries.length) {
+      $undoList.innerHTML = `<div class="empty">No recent trash deletes found.</div>`;
+      return;
+    }
+    $undoList.innerHTML = "";
+    for (const e of entries) {
+      const origName = (e.path || "").split("/").pop();
+      const age = fmtAge(e.ts ? new Date(e.ts).getTime() : null);
+      const row = document.createElement("div");
+      row.className = "undo-entry";
+      row.innerHTML = `
+        <div class="file">${escapeHtml(origName)}</div>
+        <div class="path"><span class="plabel">Orig:</span> ${escapeHtml(e.path || "?")}</div>
+        <div class="path"><span class="plabel">Trash:</span> ${escapeHtml(e.dst || "?")}</div>
+        <div class="undo-meta"><span class="undo-age">${escapeHtml(age)}</span><button class="undo-row-btn">↶ Restore</button></div>
+      `;
+      row.querySelector(".undo-row-btn").addEventListener("click", () => doUndo(e, row));
+      $undoList.appendChild(row);
+    }
+  });
+}
+
+function doUndo(e, row) {
+  const btn = row.querySelector(".undo-row-btn");
+  btn.disabled = true;
+  btn.textContent = "…";
+  $undoStatus.textContent = "";
+  chrome.runtime.sendMessage({ type: "undo-delete", dst: e.dst, path: e.path }, (r) => {
+    if (!r) { btn.disabled = false; btn.textContent = "↶ Restore"; $undoStatus.textContent = "no response"; return; }
+    if (!r.ok) { btn.disabled = false; btn.textContent = "↶ Restore"; $undoStatus.textContent = "error: " + (r.error || r.stderr || "unknown"); return; }
+    btn.textContent = "✓ restored";
+    row.style.opacity = "0.5";
+    $undoStatus.textContent = "Restored to: " + (e.path || "?");
+    // Refresh the main result after a short pause
+    setTimeout(() => {
+      $undoOverlay.style.display = "none";
+      runCheck(true);
+    }, 1200);
+  });
+}
+
+document.getElementById("undo-cancel").addEventListener("click", () => {
+  $undoOverlay.style.display = "none";
+});
+$undoBtn.addEventListener("click", openUndoModal);
+
+// ----- wiring -----
+
+document.getElementById("recheck").addEventListener("click", async () => {
+  if (settings && settings.scanPaused) {
+    await setScanPaused(false);
+    return;
+  }
+  if (manualMode && $searchInput.value.trim()) runManualSearch();
+  else runCheck(true);
+});
+document.getElementById("open-options").addEventListener("click", () => chrome.runtime.openOptionsPage());
+$modeLive.addEventListener("click", () => setSearchMode("live"));
+$modeCache.addEventListener("click", () => setSearchMode("cache"));
+$pauseScan.addEventListener("click", () => setScanPaused(!(settings && settings.scanPaused)));
+$deleteBtn.addEventListener("click", openDeleteModal);
+document.getElementById("ping").addEventListener("click", () => {
+  setStatus("pinging host…");
+  $output.textContent = "";
+  chrome.runtime.sendMessage({ type: "ping-host" }, (r) => {
+    if (!r || !r.ok) { setStatus("host unreachable", "err"); $output.textContent = r?.error || ""; return; }
+    setStatus("host ok: " + (r.version || "unknown"), "hit");
+    const rows = [
+      ["Host version",  r.version || "?"],
+      ["rc-jav path",   r.rc_jav || "?"],
+      ["Script exists", r.rc_jav_exists ? "✓ yes" : "✗ not found"],
+      ["Path source",   r.rc_jav_overridden ? "options override" : "built-in default"],
+      ["Python",        r.python || "?"],
+    ];
+    const div = document.createElement("div");
+    div.style.cssText = "font-size:12px;line-height:1.7;";
+    div.innerHTML = rows.map(([k, v]) =>
+      `<div><span style="color:#888;min-width:110px;display:inline-block;">${k}</span> <span style="color:#ddd;">${v}</span></div>`
+    ).join("");
+    $output.appendChild(div);
+  });
+});
+
+function loadCacheBanner() {
+  chrome.runtime.sendMessage({ type: "cache-status" }, (r) => {
+    if (chrome.runtime.lastError || !r || !r.ok) return; // silent fail — banner optional
+    if (!r.cache_exists) {
+      $cacheBanner.className = "no-cache";
+      $cacheBanner.textContent = "⚠ No cache — searches use quick (live) mode only. Run --scan to build.";
+      $cacheBanner.style.display = "";
+      return;
+    }
+    const staleRemotes = (r.remotes || []).filter((x) => x.stale);
+    if (!staleRemotes.length) { $cacheBanner.style.display = "none"; return; }
+    const oldest = staleRemotes.reduce((a, b) => (b.age_hours || 0) > (a.age_hours || 0) ? b : a, staleRemotes[0]);
+    const ageH = oldest.age_hours != null ? Math.round(oldest.age_hours) : "?";
+    $cacheBanner.className = "";
+    $cacheBanner.textContent = `⚠ Cache is ${ageH}h old (${staleRemotes.length} remote${staleRemotes.length > 1 ? "s" : ""} stale). Consider running --scan.`;
+    $cacheBanner.style.display = "";
+  });
+}
+
+const $profileSelect = document.getElementById("profile-select");
+$profileSelect.addEventListener("change", async () => {
+  const newProfile = $profileSelect.value;
+  // Save activeProfile to storage so background.js picks it up on next search.
+  const s = await chrome.runtime.sendMessage({ type: "get-settings" });
+  await chrome.storage.sync.set({ settings: Object.assign({}, s, { activeProfile: newProfile }) });
+  settings = Object.assign({}, s, { activeProfile: newProfile });
+  // Re-run current search with new profile
+  if (manualMode && $searchInput.value.trim()) runManualSearch();
+  else runCheck(true);
+});
+
+function renderProfileSelector(s) {
+  const profiles = s.profiles || [];
+  if (!profiles.length) { $profileSelect.style.display = "none"; return; }
+  $profileSelect.innerHTML = "";
+  const def = document.createElement("option");
+  def.value = "";
+  def.textContent = "Default";
+  $profileSelect.appendChild(def);
+  for (const p of profiles) {
+    const opt = document.createElement("option");
+    opt.value = p.name;
+    opt.textContent = p.name;
+    $profileSelect.appendChild(opt);
+  }
+  $profileSelect.value = s.activeProfile || "";
+  $profileSelect.style.display = "";
+}
+
+(async () => {
+  settings = await chrome.runtime.sendMessage({ type: "get-settings" }) || {};
+  syncModeToggle();
+  syncPauseButton();
+  renderProfileSelector(settings);
+  loadCacheBanner();
+  renderHistory(await loadHistory());
+  if (settings.scanPaused) {
+    renderPausedState();
+    return;
+  }
+  if (settings.triggers?.toolbarClick !== false) {
+    runCheck(false);
+  } else {
+    setStatus("toolbar auto-check disabled");
+    $output.innerHTML = "";
+    const div = document.createElement("div");
+    div.className = "empty";
+    div.textContent = "Use Re-Scan to check this page.";
+    $output.appendChild(div);
+  }
+})();
diff --git a/samples/sim-dupe.js b/samples/sim-dupe.js
new file mode 100644
index 0000000..b6efb42
--- /dev/null
+++ b/samples/sim-dupe.js
@@ -0,0 +1,50 @@
+// Sim Dupe preview harness — extracted from popup.js during the console
+// consolidation refactor. The Sim Dupe button was removed from the live popup
+// (see mockups/console-consolidation-claude.html, step 1 of the sequence).
+// This file preserves the fake multi-hit payload so layout/design work on
+// renderResult / renderHits can still simulate a 3-hit result without
+// running a real search.
+//
+// To re-enable temporarily for layout testing:
+//   1. Re-add the button to popup.html under #actions:
+//        <button id="sim-dupe" title="Simulate a multi-hit result (debug)">Sim Dupe</button>
+//   2. Copy the SIM_DUPE_PAYLOAD constant + the click handler below into popup.js.
+//   3. After layout work is done, remove both again so the production popup
+//      stays free of debug surfaces.
+//
+// Or, for pure visual review without rebuilding the extension:
+//   open popup.html in a browser, paste this payload into renderResult() via
+//   the devtools console.
+
+const SIM_DUPE_PAYLOAD = {
+  ok: true,
+  id: "PRTD-027",
+  hits: 3,
+  found: true,
+  cached: false,
+  structured: [
+    {
+      source: "Source", remote: "cq:JAV", jav_id: "PRTD-027",
+      path: "ClearJAV/ichika-matsumoto/PRTD-027 - Ichika Matsumoto.mkv",
+      full_path: "cq:JAV/ClearJAV/ichika-matsumoto/PRTD-027 - Ichika Matsumoto.mkv",
+      size: 7455357566, size_human: "6.94 GiB", mod_time: "",
+    },
+    {
+      source: "Target", remote: "cq:JAV", jav_id: "PRTD-027",
+      path: "K-P/P/PRTD/PRTD-027 [1080p].mp4",
+      full_path: "cq:JAV/K-P/P/PRTD/PRTD-027 [1080p].mp4",
+      size: 7463966365, size_human: "6.95 GiB", mod_time: "",
+    },
+    {
+      source: "Target", remote: "cq:JAV", jav_id: "PRTD-027",
+      path: "TMP/PRTD-027.mp4",
+      full_path: "cq:JAV/TMP/PRTD-027.mp4",
+      size: 5047288128, size_human: "4.70 GiB", mod_time: "",
+    },
+  ],
+};
+
+// Optional: paste this back next to the other action-button listeners in popup.js
+// document.getElementById("sim-dupe").addEventListener("click", () => {
+//   renderResult(SIM_DUPE_PAYLOAD);
+// });