diff --git a/.claude/hooks/post-edit.mjs b/.claude/hooks/post-edit.mjs
index 29558ac..335ff1e 100755
--- a/.claude/hooks/post-edit.mjs
+++ b/.claude/hooks/post-edit.mjs
@@ -65,11 +65,6 @@ if (problems.length) {
   process.exit(2);
 }
 
-// The file is good, so make sure it is actually VISIBLE somewhere. `ensure` is
-// idempotent and the already-running path is a pid check plus one loopback
-// request, so this costs nothing on the common path.
-try {
-  console.log(run('node', ['scripts/watch-daemon.mjs', 'ensure']).trim());
-} catch {
-  /* the live loop is a convenience; never fail an edit over it */
-}
+// There is no live-injection loop to revive here. A change reaches the browser
+// only through a real Violentmonkey install, which is the operator's action —
+// see CONTRIBUTING.md "Testing a change".
diff --git a/.claude/hooks/stop-gate.mjs b/.claude/hooks/stop-gate.mjs
index b8c3ae4..97b4765 100755
--- a/.claude/hooks/stop-gate.mjs
+++ b/.claude/hooks/stop-gate.mjs
@@ -25,17 +25,6 @@ try {
 const run = (cmd, args) =>
   execFileSync(cmd, args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
 
-// Revive the live loop on EVERY turn, not only the turns that touched a
-// userscript — "stays running" has to survive a crash during a docs change too.
-// Idempotent, and the already-running path is a pid check plus one loopback
-// request. Never allowed to block a stop.
-try {
-  const out = run('node', ['scripts/watch-daemon.mjs', 'ensure']).trim();
-  if (out && !/already running/.test(out)) console.log(out);
-} catch {
-  /* the browser is a convenience; a clean stop is not */
-}
-
 let changed = [];
 try {
   changed = run('git', ['status', '--porcelain', '--', '*.user.js'])
diff --git a/.claude/settings.json b/.claude/settings.json
index a7f1605..bc777ab 100644
--- a/.claude/settings.json
+++ b/.claude/settings.json
@@ -43,9 +43,7 @@
       "Bash(typos:*)",
       "Bash(markdownlint-cli2:*)",
       "Agent(Explore)",
-      "Agent(Plan)",
-      "Bash(node scripts/watch-daemon.mjs:*)",
-      "Bash(pkill -f chrome-for-testing:*)"
+      "Agent(Plan)"
     ],
     "deny": [
       "Bash(npm install:*)",
@@ -66,11 +64,6 @@
             "type": "command",
             "command": "node \"${CLAUDE_PROJECT_DIR:-.}/.claude/hooks/session-start.mjs\"",
             "timeout": 20
-          },
-          {
-            "type": "command",
-            "command": "node \"${CLAUDE_PROJECT_DIR:-.}/scripts/watch-daemon.mjs\" ensure",
-            "timeout": 30
           }
         ]
       }
@@ -98,18 +91,6 @@
           }
         ]
       }
-    ],
-    "SessionEnd": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"${CLAUDE_PROJECT_DIR:-.}/scripts/watch-daemon.mjs\" status",
-            "timeout": 15
-          }
-        ]
-      }
     ]
   }
 }
diff --git a/.gitignore b/.gitignore
index 6cb80e4..3cc5663 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,11 +15,6 @@ result
 result-*
 .direnv/
 
-# The browser `nix run .#watch` drives: a PROJECT-LOCAL Chrome profile plus its
-# log. Hundreds of megabytes, and it holds cookies for whatever you were testing
-# — it must never be committed, and it is not shared with your real browser.
-.nix-browser/
-
 # Editor and OS noise
 .DS_Store
 Thumbs.db
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ecd6b88..abd3fab 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,24 @@ Entries are grouped by script. Within a release, use the
 
 ## [Unreleased]
 
+### Removed
+
+- **The entire Chrome for Testing / DevTools-Protocol toolchain**, because it was
+  not the browser this project is developed against and therefore not
+  verification. Gone: `nix/chrome-for-testing.nix`, `nix/violentmonkey.nix`,
+  `scripts/cdp.mjs`, `scripts/userscript-watch.mjs`,
+  `scripts/userscript-verify.mjs`, `scripts/watch-daemon.mjs`, the `browser` /
+  `watch` / `verify` / `watch-status` / `watch-stop` / `browser-bump` flake
+  commands, the two Claude Code hooks that kept the loop alive, and the 470 MB
+  `.nix-browser/` profile. The repository went from 474 MB to **3.8 MB** on disk.
+- **The `allowUnfreePredicate` with it.** It existed to admit exactly one
+  package, Chrome for Testing; nothing unfree is left in the flake, so a
+  contributor no longer needs any unfree allowance to get a dev shell.
+- **Five ESLint globals** — `fetch`, `WebSocket`, `AbortController`, `setTimeout`,
+  `clearTimeout` — which only the CDP client needed. `scripts/` is now
+  `meta-lint.mjs` alone, and the globals list is back to what a file there
+  actually references, so `no-undef` keeps meaning something.
+
 ### Added
 
 - Repository scaffolding: contribution guide, code of conduct, security policy,
@@ -163,6 +181,36 @@ Entries are grouped by script. Within a release, use the
 
 ### Changed
 
+- **The documented way to test a change is to install it.** The browser is
+  ungoogled-chromium **152.0.7977.64** with **Violentmonkey 2.48.0** from the
+  Chrome Web Store, and the only channel into a page is the manager's own
+  install path. `CONTRIBUTING.md` gains a **Testing a change** section;
+  `CLAUDE.md`'s two browser sections were rewritten around it; `README.md` no
+  longer offers `nix run .#watch` as the one-command way to try something.
+- **Why, stated as the trade it was.** The CDP lane ran a different browser at a
+  different version against a throwaway profile, so whatever it proved was not
+  what a reader gets. It was measured drifting: a feature was reported "verified
+  on all five hosts" against Chrome for Testing **154** on a machine whose actual
+  browser is **152**, and two of those five hosts turned out to be scroll-locked
+  in ways the rig papered over. thumbwall's own `WHY` block had recorded its
+  original measurements on `Chromium 152.0.7977.64` all along — the real browser.
+- **Measuring a selector is now the script's own job.** `selector-verify.mjs`
+  returned a `GENERATED` verdict mechanically; with no tool, `CONTRIBUTING.md` §
+  Measure the live page carries the rule instead — anchor on ARIA roles, `href`
+  values and data attributes, never a generated class and never `aria-label` or
+  link text, both of which are localised. Log the count from the script behind a
+  debug flag that ships off, and break the selector on purpose to prove the
+  failure mode.
+- **Two findings kept as page facts, not rig facts.** xhamster ships
+  `body.xh-scroll-disabled` (`overflow-y: hidden`) on a clean profile with no
+  dialog behind it, and pornhub holds `scrollHeight === innerHeight` behind its
+  age modal. Both measured 2026-09-29 identical with a script armed and with it
+  torn down, so neither is the script's doing — check the page scrolls at all
+  before blaming a scroll-driven feature.
+- The per-host marked-node counts in `CLAUDE.md`'s script map (106 / 153 / 108 /
+  1439) are labelled as CDP-era figures: orders of magnitude, not numbers to diff
+  against.
+
 - CI's Node is 20 → **22**, matching `nodejs_22` in `flake.nix`, so the npm path
   and the flake path run ESLint on the same runtime. Node 20 went end-of-life in
   April 2026 and eslint 10 wants `^20.19 || ^22.13 || >=24`.
diff --git a/CLAUDE.md b/CLAUDE.md
index 030f7e7..01f1381 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -102,9 +102,6 @@ fix                              # eslint --fix + markdownlint --fix
 bump <script> [patch|minor|major|x.y.z]   # the @version trap, mechanised
 publish-check <script>           # version, CHANGELOG, listing and README row in one pass
 new-script <name>                # scaffold a script + listing; passes all gates as generated
-browser [--violentmonkey]        # the pinned browser, project-local profile
-watch [--hot] [--violentmonkey]  # ^ plus the scripts injected, live on every save
-browser-bump [version]           # refresh the Chrome for Testing pin
 diagram [file]                   # mermaid -> ASCII for listings/*.md, capped at 80 columns
 check-versions                   # @version monotonicity vs origin/main
 deps                             # point ./node_modules at the flake-pinned tree
@@ -112,6 +109,11 @@ ci                               # everything CI runs, in CI's order
 nix flake check                  # every OFFLINE gate, sandboxed
 ```
 
+**`browser`, `watch`, `verify` and `browser-bump` are deliberately NOT in that list.** They
+drive Chrome for Testing over CDP, which is not the browser here and not the channel here - see
+"The browser, and how a change is actually verified" below. They still run if you invoke them;
+their output is not verification and must never be reported as such.
+
 **`bump` rather than editing the `@version` line by hand.** It preserves the metadata block's
 alignment and refuses any number that does not clear both the working copy and `origin/main` -
 which is the trap below, enforced instead of remembered.
@@ -154,176 +156,111 @@ written into a live DOM attribute), `pagin` (a substring selector, `[class*="pag
 `contener` (the site's own misspelling in an id we have to match). Add a fourth only with the
 same kind of note.
 
-## The browser, and watching a script live
+## The browser, and how a change is actually verified
 
-**`nix run .#watch` is the loop.** It starts **Chrome for Testing 154.0.8037.57**, pinned in
-`nix/chrome-for-testing.nix` and never self-updating, against a **project-local profile** at
-`.nix-browser/profile` - so a debugger is never pointed at the operator's own session, cookies or
-history. Then it injects every `.user.js` over CDP and re-injects on save.
+**THE ONLY BROWSER IS UNGOOGLED-CHROMIUM, AND THE ONLY CHANNEL IS A REAL
+VIOLENTMONKEY INSTALL.** Verified on disk 2026-09-29:
 
-```bash
-nix run .#watch                        # reload on save - faithful document-start
-nix run .#watch -- --hot               # swap in place, no reload - fast, less faithful
-nix run .#watch -- --scroll            # rehydrate lazy content after each reload
-nix run .#watch -- --violentmonkey     # a REAL install in Violentmonkey 2.49.0
+| | what is actually here |
+|---|---|
+| browser | **Chromium 152.0.7977.64**, `/Applications/Chromium.app` |
+| profile | the operator's own, `~/Library/Application Support/Chromium/Default` |
+| manager | **Violentmonkey 2.48.0**, from the Chrome Web Store, id `jinjaccalgkegednnccohejagnlnfdag` |
+| channel | the manager's own install/update path - **nothing else** |
 
-nix run .#verify -- <url> --expect data-nix-leolist-listings-only
-```
+**No Chrome for Testing. No CDP.** Not `nix run .#watch`, not `nix run .#verify`,
+not page-lab's `selector-verify.mjs` on `:9222`, not `chrome-devtools-mcp`, not
+kapture, not `mcp__claude-in-chrome`. Do not start one, do not attach to one, do
+not assume one is listening.
 
-**`verify` is the check, and its wheel-scroll step is the whole point.** It answers four
-questions in order: did the script **run**, did it **throw**, did it **arm**, and did the lazy
-content actually **hydrate**. Exit 1 on a script that never ran, threw, or left a broken image.
-Not arming is *not* a failure unless you name the attribute you expected - `--expect` takes the
-attribute name because "armed" is not one bit: on leolist's homepage `data-nix-leolist-dark` is
-present (theme, site-wide) and `data-nix-leolist-listings-only` is absent, and **both are
-correct**.
+**Why, stated as the trade it is.** The CDP lane runs a *different browser* at a
+*different version* against a *throwaway profile*. Whatever it proves is not
+what a reader gets, so it is not verification - it is a demo that happens to be
+scriptable. It is also the operator's own profile and these are adult sites,
+which is the second, independent reason an agent does not drive it.
 
-**`--gate` answers "why not?" when a script declines.** It replays a grid-gallery gate signal by
-signal - grids matched, and per grid: renders / kids / units / rows / organic share - then whether
-a pager was found and whether it sits inside the winning grid.
+The drift was real and it was measured: a whole feature was "verified on all
+five hosts" over CDP against Chrome for Testing **154**, on a machine whose
+actual browser is **152** - and two of the five hosts turned out to be
+scroll-locked in ways the rig papered over. Note that thumbwall's own `WHY`
+block records its original measurements on `Chromium 152.0.7977.64`: the real
+browser. The 154 lane was the newer, wrong thing layered on top.
 
-```bash
-nix run .#verify -- <url> --expect data-ph-thumbwall --gate 'ul.videos,/view_video.php'
-nix run .#verify -- <url> --expect data-xh-thumbwall --gate 'div.thumb-list,/videos/'
-```
+### The loop
 
-**It takes the constants rather than knowing them**, and it only fits the gate shape
-`runPornhub()` and `runXhamster()` share. `runXnxxXvideos()` and `runEporner()` are built
-differently - `.mozaique` plus a named `PAGER_SEL` - so the flag does not apply there. Read the
-constants out of the module and pass them; a built-in copy would be stale within the week.
-
-**If the replica disagrees with the script, the replica is wrong.** A gate reporting "all signals
-pass" while the script declines means wrong constants or a wrong `--expect` attribute - it printed
-exactly that on pornhub and xhamster while both were in fact arming under names I was not
-checking. `verify` says so on that line rather than letting you file a bug against working code.
-
-**The two scripts do not share a marker namespace.** `leolist-listings-only` writes
-`nix-leolist-*` and `data-nix-leolist-*`; `thumbwall` writes `nx-*` and `data-nx-thumbwall`.
-`verify` matches both by default and takes `--prefix` for a third - because a tool hardcoding one
-of them reports a clean "0 injected, not armed" for the other script on every page it actually
-works on, which is the exact false negative this command exists to stop.
-
-**`window.scrollTo` is the scroll-shaped version of `el.click()`.** leolist sets
-`html { overflow: hidden }` and scrolls its listing column, so `scrollTo` moved a number the page
-never heard about: `scrollY` stayed `0` through six attempts while an `IntersectionObserver`
-waited for a scroll that never came, and a filmstrip of **759 photos measured as ZERO**. One
-dispatched wheel event took the same page from 29 images to 1201. Measured 2026-09-29. Use
-`Input.dispatchMouseEvent` with `type: "mouseWheel"`; never `window.scrollTo`.
-
-**THE HOOKS KEEP IT UP, so normally you never type it.** `scripts/watch-daemon.mjs ensure` runs
-at session start, after any `.user.js` edit, and at the end of every turn. It is idempotent, it
-survives the session that started it (PPID 1), and it restarts the loop if it died.
-
-```bash
-nix run .#watch-status    # is it up?
-nix run .#watch-stop      # take it down
+```text
+you edit <name>.user.js  ->  Ismail reloads it in Violentmonkey  ->  Ismail reports
 ```
 
-Set `USERSCRIPTS_WATCH=0` (in `.envrc.local`) to switch the auto-start off entirely.
-
-**The daemon NEVER attaches to a browser it did not start.** Typing `nix run .#watch` yourself
-attaches to whatever answers CDP on the port - correct, because you asked for it. A hook doing
-the same thing would inject these scripts into whatever Chromium happens to be on 9222, which on
-this machine is the operator's own profile. So the daemon tracks what it started in
-`.nix-browser/watch.json` and declines with a reason otherwise.
-
-- **It attaches rather than launches** when something already answers CDP on the port, and then
-  leaves that browser running when it exits. A browser it started, it also kills.
-- **The default port is 9222**, which is the port `page-lab`'s `selector-verify.mjs` below
-  already expects - so `watch` and the measuring tools are the same browser.
-- **A save that does not parse never reaches the page.** `node --check` runs first; the error
-  prints and the browser keeps the last good version.
-- **`USERSCRIPTS_CHROME=/path/to/chrome`** overrides the pin when you need the browser you
-  actually have. Nothing else does - an installed browser self-updates, and then a measurement
-  note names a version that no longer exists.
-
-**Why CDP injection is faithful HERE.** `Page.addScriptToEvaluateOnNewDocument` runs before any
-page script on every navigation, which is what `@run-at document-start` means, and the `@match` /
-`@noframes` gates are compiled into the payload and evaluated in-page - so every other page is
-left stock, exactly as installed. What it cannot do is provide manager APIs. **Every script here
-is `@grant none`, so nothing is missing** - and if one ever grants something, `watch` refuses to
-inject it and tells you to use the Violentmonkey lane instead.
-
-**Three traps already paid for, all measured 2026-09-29:**
-
-- **CDP injection runs EARLIER than a manager's document-start, and that broke
-  `leolist-listings-only`.** At `addScriptToEvaluateOnNewDocument` time the document is
-  *completely empty* - `documentElement` is `null`, `document.childNodes.length` is `0`,
-  `readyState` is `"loading"`. A Chrome content script at `document_start` runs a moment later,
-  once the parser has created `<html>` and before any other DOM. The script touches
-  `documentElement.dataset` immediately and died with **"Cannot read properties of null"** -
-  which, correctly, left the page rendering **stock**, so nothing looked broken except that
-  nothing happened. `watch` now waits for `<html>` via a `MutationObserver` on `document`.
-  **If you ever hand-roll an injection, do the same** - do not run earlier than the thing you
-  are reproducing.
-
-- **`--hot` cannot exercise a document-start gate.** The page has already painted, so a theme or
-  pre-paint attribute gate has nothing to gate. Iterate in `--hot`; **sign off on a reload.**
-- **Registering against an already-open tab does nothing on its own.**
-  `addScriptToEvaluateOnNewDocument` affects the NEXT navigation only, so `watch` reloads every
-  page that was already open when it attached. Without that, the script is registered and not
-  running - a symptom indistinguishable from a dead selector.
-
-The Violentmonkey lane is the one that matches a reader exactly: a real install, the manager's
-own update path. It costs two one-time clicks per profile (Details -> *Allow access to file
-URLs*, then open the `.user.js` `file://` URL and tick **Track local file**). `--load-extension`
-was verified working on Chrome for Testing 154 despite the Chrome 137+ restriction elsewhere.
+That is the whole loop, and **the middle step is his, not yours.** Plan the work
+around a human-in-the-loop turnaround rather than around a measurement you can
+run yourself. Concretely:
+
+- **Ask for one install and one report, not five.** Batch every question a build
+  needs to answer into that single round trip.
+- **Make the script report on itself.** When something needs measuring, have the
+  script compute it and log it - counts, the selector that matched, the URL it
+  fetched, the gate signal that failed - so a paste from the console answers the
+  question. A script that can only be understood by inspecting the DOM by hand
+  costs him the work instead of doing it.
+  Put it behind a flag the reader never trips (a `localStorage` key, or a
+  constant at the top of the file that ships `false`), and **never** leave a
+  release logging on every page load.
+- **`@version` still gates the reload.** Violentmonkey never downgrades and a
+  same-version reinstall is a silent no-op, so bump it or he will be testing the
+  old code and reporting on it in good faith. See the `@version` trap below.
+- **Opening the target page is his action.** These are adult sites. Ask for the
+  page; never navigate anything there yourself.
+
+### There is no CDP tooling left
+
+Removed 2026-09-29, in full: `nix/chrome-for-testing.nix`, `nix/violentmonkey.nix`,
+`scripts/cdp.mjs`, `scripts/userscript-watch.mjs`, `scripts/userscript-verify.mjs`,
+`scripts/watch-daemon.mjs`, the `browser` / `watch` / `verify` / `watch-status` /
+`watch-stop` / `browser-bump` flake commands, the two Claude Code hooks that kept
+the loop alive, and the 470 MB `.nix-browser/` profile. The flake needs no
+`allowUnfreePredicate` any more, because nothing unfree is left in it.
+
+**Do not reintroduce any of it.** If a future task seems to need a scriptable
+browser, the answer is a better self-reporting script, not a second browser -
+see the loop above.
+
+Two lessons from that lane are worth keeping, because they are about the *page*,
+not the rig:
+
+- **A dispatched wheel event is the only real scroll.** `window.scrollTo` moves a
+  number a page with an inner scroller never hears about - leolist measured a
+  759-photo filmstrip as ZERO that way (2026-09-29). Under a real install this is
+  moot for verification, since the operator scrolls with an actual wheel; it
+  still matters for any code that synthesises scrolling.
+- **Some sites are scroll-locked before you arrive.** Measured 2026-09-29:
+  xhamster ships `body.xh-scroll-disabled` (`overflow-y: hidden`) on a clean
+  profile with no dialog behind it, and pornhub holds `scrollHeight ===
+  innerHeight` behind its age modal - both **identical with a script armed and
+  with it torn down**, so neither is ours. Confirm the page scrolls at all before
+  concluding a scroll-driven feature is broken.
 
 ## Measuring the live page
 
-CONTRIBUTING.md says "measure first, never guess a selector" but does not say *with what*.
-Chromium runs with `--remote-debugging-port=9222` - `nix run .#watch` is now the deterministic
-way to get one - and page-lab ships the tooling:
-
-```bash
-pl=$(ls -d ~/.claude/plugins/cache/*/page-lab/*/scripts | tail -1)
-
-bash "$pl/page-route.sh"          # FIRST - which browser route is up. Most "broken
-                                  # selector" reports are an unreachable browser.
-node "$pl/selector-verify.mjs" --target-id "$tid" '<sel>' ...
-bash "$pl/devtools-doctor.sh"     # triage when the route is down
-node "$pl/survey-recon.mjs"       # survey a page before redesigning it
-```
-
-Resolve `$pl` with the glob - a bare path pins one plugin revision and several are installed.
-The `page-lab:pick` skill is the other path: the operator points at an element and you get a
-dated, verified selector back.
-
-`selector-verify.mjs` returns `UNIQUE` / `AMBIGUOUS` / `DEAD` / **`GENERATED`** - that last
-verdict *mechanically enforces* the no-generated-class-names rule this repo states in prose. Use
-it rather than eyeballing.
-
-**Three traps, all hit for real:**
-
-- **`--target-id` is not optional.** The default ("first page target") silently scores against a
-  Violentmonkey extension page. Same selectors, same instant: `DEAD` without it, `UNIQUE` with
-  it. Get the id from `curl -s localhost:9222/json/list`.
-- **Verify against a *stock* page.** Tear the script down first (the teardown globals are listed
-  under "Script map" below). A selector for a node the script has already relocated reads `DEAD`
-  while the script is live - you would be measuring your own output.
-- **`chrome-devtools-mcp` points at the wrong browser.** It is launched with a
-  `--userDataDir` of its own; the page under test is **Chromium on `:9222`**. Kapture
-  (`mcp__kapture__*`) is also live but needs an operator click to attach a tab - and a
-  `kapture-N` id is a **minted** id that evaporates on reload, so a selector built on one dies
-  silently after the session it was written in.
-
-**Opening the target page is the operator's action.** These are adult sites; an agent does not
-navigate the operator's browser there unasked. Ask for the tab, then measure it. `nix run .#watch`
-deliberately opens **no URL** of its own for the same reason.
-
-**Injecting is not installing.** `nix run .#watch` now removes the first two of these - it
-strips the metadata block itself and registers at document-start - so they apply to a HAND-ROLLED
-`Runtime.evaluate` injection, which is what you fall back to when measuring one-off:
-
-- Strip the `// ==UserScript== … ==/UserScript==` block first - metadata, not JS.
-- These scripts are `@run-at document-start`. Injected at `readyState: complete` they run against
-  a page that already painted, so a document-start gate (theme, pre-paint attribute on `<html>`)
-  has nothing to gate. Expect a flash the real install does not have. This is also exactly why
-  `watch --hot` is for iterating and a reload is for signing off.
-- Animations and transitions are still mid-flight on injection. **Poll until a measured value
-  stops changing**; a fixed sleep races it, and two equal reads are not proof - require three.
-- Re-injection is exactly the double-injection case the teardown contract exists for, so it
-  doubles as the livelock test.
+**Measure first, never guess a selector** still stands - what changed is the
+instrument. There is no CDP, so a selector is verified by the script itself, on
+the page, in the operator's browser:
+
+- **Write the candidate selector into the script behind a debug flag**, have it
+  log the match count and the first match's tag/id/class, and ask for that one
+  line back. That is the userscript-only equivalent of `selector-verify.mjs`'s
+  `UNIQUE` / `AMBIGUOUS` / `DEAD` verdict, and it has the advantage of scoring
+  the selector in the exact browser and profile that will run it.
+- **`GENERATED` has no tool here, so the rule carries itself.** Anchor on ARIA
+  roles, `href` values and data attributes. Never a generated class
+  (`searchSubmit-e1b81`, `root-f87d5`), and never `aria-label`, which is
+  localised - reading one to find a node matches nothing on a non-English UI.
+  Setting `aria-label` on a node **we** create is fine and expected.
+- **Verify against a stock page.** Ask him to disable the script (or use the
+  teardown global from the Script map below) before reading counts, or you are
+  measuring your own output.
+- **Break your own selector on purpose** and confirm the page renders stock. That
+  test needs no tooling at all and it is the one that proves the failure mode.
 
 ## The `@version` trap (has bitten more than once)
 
@@ -399,10 +336,11 @@ for each site's measured quirks, a dispatch table keyed on `location.hostname`.
 
 **EVERY MODULE HAS ITS OWN ATTRIBUTE NAMESPACE** - `nx`, `ep`, `xh`, `ph` - and so does
 `leolist-listings-only` (`nix`). Checking one of them across all five hosts is how three working
-modules got written up as broken for twenty minutes (2026-09-29). `nix run .#verify` knows all
-five; if you check by hand, check the RIGHT one. Verified armed 2026-09-29 on
-`pornhub.com/video?o=mr` (106 marked nodes), `xhamster.com/newest` (153),
-`eporner.com/most-viewed/` (108) and `xnxx.com/best/2026-08` (1439).
+modules got written up as broken for twenty minutes (2026-09-29). **Check the RIGHT one**, and
+when you ask the operator to check, name the attribute rather than saying "is it armed". Counts
+recorded 2026-09-29 - `pornhub.com/video?o=mr` 106 marked nodes, `xhamster.com/newest` 153,
+`eporner.com/most-viewed/` 108, `xnxx.com/best/2026-08` 1439 - were taken over CDP against
+Chrome for Testing 154, so treat them as ORDERS OF MAGNITUDE, not as figures to diff against.
 
 - **xnxx and eporner are carried forward VERBATIM** - byte-for-byte the gate, theme engine and
   purge rules that shipped as 2.2.0 and 2.3.0, each the product of field reports fixed under time
@@ -455,15 +393,15 @@ control.
 
 That is a **real gap, not a convention**: the sibling repo shipped a build that passed lint and
 every geometry check with its search **completely dead**, because nobody had ever clicked it.
-Until specs exist here, clicking through every primary action under a trusted event is a manual
-step you must actually do - and writing the first spec is a welcome change.
-
-The runner, if you add one:
-
-```bash
-pl=$(ls -d ~/.claude/plugins/cache/*/page-lab/*/scripts | tail -1)
-node "$pl/userscript-acceptance.mjs" --repeat 3 <name>.acceptance.mjs
-```
+Until specs exist here, clicking through every primary action is a manual step **the operator
+performs**, on a real install, and reports back. For this repo that means: click a card through
+to its own page, open the filter sidebar and tick a filter, play a video.
+
+**page-lab's `userscript-acceptance.mjs` runner is NOT the answer here** - it drives a browser
+over CDP, which is neither the browser nor the channel in use (see below). A spec format that
+suits this repo would have to run **inside** the script, behind a debug flag, and print its
+pass/fail lines to the console for the operator to paste back. Writing that is a welcome change;
+wiring up a CDP runner is not.
 
 ## How changes land
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 863bca9..b0e4fd7 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -9,6 +9,7 @@ method — read the section that matches what you are doing.
 - [The metadata block](#the-metadata-block)
 - [Which fork does my script go to?](#which-fork-does-my-script-go-to)
 - [The `@version` trap](#the-version-trap)
+- [Testing a change](#testing-a-change)
 - [Measure the live page — never guess a selector](#measure-the-live-page--never-guess-a-selector)
 - [Lint gates](#lint-gates)
 - [Adding a new script](#adding-a-new-script)
@@ -49,12 +50,6 @@ them as `nix run .#<name>`, or bare inside `nix develop`.
 | `publish-check <script>` | every pre-publish condition, as a checklist |
 | `new-script <name>` | scaffold a script + listing with the design rules wired in |
 | `check-versions` | `@version` monotonicity against `origin/main` |
-| `browser [--violentmonkey]` | the pinned browser, on a project-local profile |
-| `watch [--hot] [--violentmonkey]` | the same browser, with every script injected and re-injected on save |
-| `browser-bump [version]` | refresh the pinned Chrome for Testing |
-| `verify <url> [--expect <attr>]` | did the script run, throw, arm and hydrate on that page? |
-| `verify … --gate '<sel>,<href>'` | and if it declined, which gate signal failed |
-| `watch-status` / `watch-stop` | inspect or stop the loop the Claude Code hooks keep alive |
 | `diagram [file]` | Mermaid → ASCII for `listings/*.md`, capped at 80 columns |
 | `link-check` | lychee over every `*.md` (**network**) |
 | `deps` | point `./node_modules` at the flake-pinned tree — no `npm install` |
@@ -71,39 +66,6 @@ packaged in nixpkgs. It is still deterministic: `importNpmLock` builds
 `node_modules` straight from `package-lock.json` using the integrity hash
 already recorded there, so no step in this flake touches the network.
 
-### Trying a script in a browser
-
-```bash
-nix run .#watch                      # pinned Chromium + every script, live on save
-nix run .#watch -- --hot             # swap in place with no reload, for iterating
-nix run .#watch -- --violentmonkey   # a real install, the way a reader runs it
-```
-
-`nix/chrome-for-testing.nix` pins **Chrome for Testing 154.0.8037.57**, which
-never self-updates — so "measured on 154.0.8037.57" stays a checkable claim.
-`pkgs.chromium` is Linux-only in nixpkgs, and an installed browser updates out
-from under a measurement; this is the version everyone gets.
-
-The profile lives at `.nix-browser/profile`, **project-local and gitignored**.
-Your own session, cookies and history are never inside this tool's reach.
-
-Injection is faithful because every script here is `@grant none` and registers
-at document-start. **Iterate with `--hot`; sign off on a reload** — an
-already-painted page gives a document-start gate nothing to gate.
-
-**Measure after a real scroll, never `window.scrollTo`.** A page that scrolls an
-inner column never hears about `scrollTo`, so anything behind an
-`IntersectionObserver` measures as absent. `nix run .#verify` dispatches real
-wheel events until hydration stops growing; `nix run .#watch -- --scroll` does a
-shorter sweep after each reload.
-
-If you use Claude Code here, its hooks keep that loop running for you
-(`scripts/watch-daemon.mjs`): started at session start, revived after any
-`.user.js` edit and at the end of every turn, and left running when the session
-ends. `USERSCRIPTS_WATCH=0` turns it off. It only ever manages a browser **it
-started** — it will never attach to one already on the port, because that one is
-probably yours.
-
 ## Repository shape
 
 ```text
@@ -190,16 +152,75 @@ Pick the right one up front. Record which in the README catalogue table.
 
 CI fails a PR that changes a `.user.js` without raising its `@version`.
 
+## Testing a change
+
+**The only channel into a page is a real userscript install**, in the browser
+this repository is developed against:
+
+| | what is used |
+|---|---|
+| browser | ungoogled-chromium **152.0.7977.64** |
+| manager | **Violentmonkey 2.48.0**, installed from the Chrome Web Store |
+| profile | the developer's own |
+
+There is no headless lane and no DevTools-Protocol lane. A change is tested by
+installing it — edit the `.user.js`, raise `@version`, reload it in Violentmonkey,
+open the target page, and look.
+
+**Raise `@version` or you are testing the old code.** Violentmonkey never
+downgrades, and a same-version reinstall is a silent no-op with nothing anywhere
+saying so. See [The `@version` trap](#the-version-trap).
+
+**Make the script answer the question.** When something needs counting — how many
+nodes a selector matched, which gate signal failed, what URL was fetched — have
+the script compute it and `console.log` it behind a debug flag that ships off,
+rather than inspecting the DOM by hand. It is faster, it is repeatable, and it
+scores the selector in the exact browser that will run it.
+
+### Reloading without a reinstall each round
+
+One-time setup in Violentmonkey:
+
+1. Chromium → Extensions → Violentmonkey → **Details** → *Allow access to file
+   URLs*.
+2. Open the `.user.js` as a `file://` URL and install it.
+3. In the script's settings, tick **Track local file**.
+
+Violentmonkey then picks the file up on save.
+
+### Two things that are not your bug
+
+**A real scroll, never `window.scrollTo`.** A page that scrolls an inner column
+never hears about `scrollTo`, so anything behind an `IntersectionObserver`
+measures as absent — leolist read a 759-photo filmstrip as ZERO that way. You
+scroll with an actual wheel here, so this is a rule for code that *synthesises*
+scrolling, not for testing.
+
+**Check the page scrolls at all before blaming your own feature.** Measured
+2026-09-29: xhamster ships `body.xh-scroll-disabled` (`overflow-y: hidden`) on a
+clean profile with no dialog behind it, and pornhub holds
+`scrollHeight === innerHeight` behind its age modal. Both are identical with a
+script running and with it torn down, so neither is the script's doing.
+
 ## Measure the live page — never guess a selector
 
 A selector that was not verified against the live page is a guess, and guesses
 rot silently. Before you write one:
 
 1. Open the target page **with every userscript disabled** — otherwise you are
-   measuring your own output, not the site.
-2. Confirm your selector matches **exactly** the node count you intend.
-3. Confirm it does not rely on a generated class name.
-4. Note the date you measured in the script's header comment.
+   measuring your own output, not the site. (Each script's teardown global,
+   documented in its header, tears it down without uninstalling.)
+2. Confirm your selector matches **exactly** the node count you intend, by
+   logging the count from the script itself.
+3. Confirm it does not rely on a **generated class name** (`searchSubmit-e1b81`,
+   `root-f87d5`) — anchor on ARIA roles, `href` values and data attributes.
+4. Confirm it does not rely on **`aria-label` or on link text**. Both are
+   localised, so either matches nothing on a non-English UI. Setting
+   `aria-label` on a node *you* create is fine and expected.
+5. Note the date **and the browser version** you measured in the script's header
+   comment.
+6. **Break the selector on purpose** and confirm the page renders stock. That is
+   the test that proves the failure mode, and it needs no tooling at all.
 
 A header comment asserting behaviour the code does not perform is a **defect**,
 not stale documentation. Update the comment and the measurement together.
diff --git a/README.md b/README.md
index 112728d..875ba80 100644
--- a/README.md
+++ b/README.md
@@ -80,15 +80,12 @@ toolkit         # list every maintenance command
 lint            # the two gates CI requires
 ```
 
-Trying a change in a real browser is one command:
-
-```bash
-nix run .#watch     # pinned Chromium, every script injected, re-injected on save
-```
-
-It starts **Chrome for Testing 154**, pinned and non-self-updating, on a
-project-local profile, and re-injects each `.user.js` the moment you save it —
-so "measured on 154.0.8037.57" stays a claim anybody can check.
+**Trying a change means installing it.** There is no headless lane and no
+DevTools-Protocol lane: these scripts are developed against ungoogled-chromium
+with **Violentmonkey** installed from the Chrome Web Store, which is the way a
+reader runs them. Edit the `.user.js`, raise `@version`, reload it in
+Violentmonkey, open the page. See
+[CONTRIBUTING.md § Testing a change](CONTRIBUTING.md#testing-a-change).
 
 `nix flake check` runs every gate that works offline, in a sandbox — the same
 set `.github/workflows/nix.yml` runs. There is still **no build step**, and
diff --git a/eslint.config.mjs b/eslint.config.mjs
index 9c7bd3a..e539f60 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -154,18 +154,15 @@ export default [
     languageOptions: {
       ecmaVersion: 2023,
       sourceType: 'module',
+      // Exactly what scripts/ and .claude/hooks/ actually reference today.
+      // The CDP set (fetch, WebSocket, AbortController, setTimeout,
+      // clearTimeout) went with the browser tooling in 2026-09-29; add one
+      // back only when a file here really uses it, so no-undef keeps meaning
+      // something.
       globals: {
         console: 'readonly',
         process: 'readonly',
         URL: 'readonly',
-        // scripts/userscript-watch.mjs speaks CDP over Node 22's own global
-        // WebSocket and fetch — no dependency, so nothing is added to
-        // package-lock.json for it.
-        fetch: 'readonly',
-        WebSocket: 'readonly',
-        AbortController: 'readonly',
-        setTimeout: 'readonly',
-        clearTimeout: 'readonly',
       },
     },
     rules: {
diff --git a/flake.nix b/flake.nix
index 71a6b79..6c35732 100644
--- a/flake.nix
+++ b/flake.nix
@@ -40,27 +40,12 @@
         "aarch64-linux"
         "x86_64-linux"
       ];
-      # A NARROW unfree allowance, never a blanket one. Chrome for Testing is a
-      # Google binary under Chrome's terms, so nixpkgs refuses it by default —
-      # and a public repository must not require a contributor to set
-      # allowUnfree globally just to get a dev shell. The predicate names
-      # exactly one package; everything else stays refused, google-chrome
-      # included.
-      pkgsFor =
-        system:
-        import nixpkgs {
-          inherit system;
-          config.allowUnfreePredicate = p: lib.getName p == "chrome-for-testing";
-        };
+      pkgsFor = system: import nixpkgs { inherit system; };
       forAll = f: lib.genAttrs systems (system: f system (pkgsFor system));
 
-      # Packages that are not commands. They stay out of `apps`, and `browser`
-      # stays out of `checks` too — it is a 361 MB download, and a gate that
-      # fetches a browser is not a gate anybody runs twice.
+      # Packages that are not commands. They stay out of `apps`.
       nonApps = [
         "mermaid-ascii"
-        "chromium"
-        "violentmonkey"
       ];
 
       # ── Env catalogue ────────────────────────────────────────────────────
@@ -190,17 +175,6 @@
 
           mermaid-ascii = pkgs.callPackage ./nix/mermaid-ascii.nix { };
 
-          # Google publishes Chrome for Testing for mac-arm64, mac-x64 and
-          # linux64 — and NOT for aarch64-linux, where nixpkgs' own chromium
-          # does build. One name, the best available build behind it.
-          chromiumPkg =
-            if system == "aarch64-linux" then
-              pkgs.chromium
-            else
-              pkgs.callPackage ./nix/chrome-for-testing.nix { };
-
-          violentmonkeyPkg = pkgs.callPackage ./nix/violentmonkey.nix { };
-
           # The trailing newline is load-bearing: `while IFS= read` drops a
           # final line that has none, which silently hid the last variable.
           envTsvFile = pkgs.writeText "userscripts-env-catalogue.tsv" (envTsv + "\n");
@@ -259,100 +233,6 @@
             }
           '';
 
-          # Shared by `browser` and `watch` so the two can never disagree about
-          # which binary, which profile or which port.
-          browserPrelude = ''
-            PORT="''${USERSCRIPTS_CDP_PORT:-9222}"
-            PROFILE="''${USERSCRIPTS_PROFILE:-$PRJ/.nix-browser/profile}"
-            # USERSCRIPTS_CHROME is the escape hatch for "test it on the browser
-            # I actually have". It is NOT the default, because an installed
-            # browser self-updates, and then no measurement note can name a
-            # version that still exists.
-            BROWSER_BIN="''${USERSCRIPTS_CHROME:-${lib.getExe chromiumPkg}}"
-            VM_DIR="${violentmonkeyPkg}"
-            # `export`, for the same reason the main prelude exports: `browser`
-            # and `watch` share this file and only `watch` reads HOT, so a plain
-            # assignment reads as dead to shellcheck (SC2034) and fails the
-            # build of the command that does not use it.
-            export HOT=""
-            export SCROLL=""
-            HEADLESS=""
-            CHROME_ARGS=()
-            URLS=()
-
-            _usage() {
-              cat <<'USAGE'
-            usage: <command> [--violentmonkey] [--hot] [--port N] [--] [url ...]
-
-              --violentmonkey  load the pinned Violentmonkey and verify the way a
-                               READER runs it - a real install, with the manager's
-                               own update path. Two one-time clicks per profile.
-              --hot            watch only: swap the script into the live page with
-                               no reload. Fast, but a document-start gate has
-                               nothing to gate on an already-painted page.
-              --scroll         watch only: after each reload, drive a real wheel
-                               event until lazy content stops appearing. A reload
-                               lands on an UNHYDRATED page, so without this an
-                               IntersectionObserver-gated feature looks absent.
-              --headless       run headless (--headless=new). For a scripted check;
-                               you cannot judge a redesign you cannot see.
-              --port N         CDP port (default 9222 - the port page-lab's
-                               selector-verify.mjs already expects).
-
-            env: USERSCRIPTS_CHROME, USERSCRIPTS_PROFILE, USERSCRIPTS_CDP_PORT
-            USAGE
-            }
-
-            _parse_browser_args() {
-              local vm=0
-              while [ $# -gt 0 ]; do
-                case "$1" in
-                  --violentmonkey) vm=1; shift ;;
-                  --hot) HOT=1; shift ;;
-                  --scroll) SCROLL=1; shift ;;
-                  --headless) HEADLESS=1; shift ;;
-                  --port) PORT="$2"; shift 2 ;;
-                  -h | --help) _usage; exit 0 ;;
-                  --) shift; URLS+=("$@"); break ;;
-                  -*) echo "unknown option: $1" >&2; _usage >&2; exit 2 ;;
-                  *) URLS+=("$1"); shift ;;
-                esac
-              done
-              CHROME_ARGS=(
-                --user-data-dir="$PROFILE"
-                --remote-debugging-port="$PORT"
-                --no-first-run
-                --no-default-browser-check
-              )
-              # --headless=new, never the old --headless: the old one is a
-              # separate, thinner implementation whose rendering and extension
-              # support differ from the browser a reader actually runs.
-              [ -n "$HEADLESS" ] && CHROME_ARGS+=(--headless=new)
-              if [ "$vm" = 1 ]; then
-                CHROME_ARGS+=(--disable-extensions-except="$VM_DIR" --load-extension="$VM_DIR")
-                echo "[browser] Violentmonkey $VM_DIR"
-                echo "[browser] one-time, per profile: chrome://extensions -> Violentmonkey ->"
-                echo "[browser]   Details -> Allow access to file URLs, then open the .user.js"
-                echo "[browser]   file:// URL and tick 'Track local file' on the install page."
-              fi
-            }
-
-            _prepare_profile() {
-              # A PROJECT-LOCAL profile, always. These scripts target adult sites;
-              # pointing a debugger at the operator's real profile would put their
-              # own session, cookies and history inside this tool's blast radius.
-              mkdir -p "$PROFILE"
-            }
-
-            _refuse_if_port_busy() {
-              if curl -fsS --max-time 1 "http://127.0.0.1:$PORT/json/version" >/dev/null 2>&1; then
-                echo "something is already answering CDP on $PORT." >&2
-                echo "attach to it with 'nix run .#watch', or pick another --port." >&2
-                exit 1
-              fi
-            }
-          '';
-
           mk =
             {
               name,
@@ -376,8 +256,6 @@
         in
         {
           inherit mermaid-ascii;
-          chromium = chromiumPkg;
-          violentmonkey = violentmonkeyPkg;
 
           # ── The two publish gates ──────────────────────────────────────
           lint = mk {
@@ -783,124 +661,6 @@
             '';
           };
 
-          # ── The browser ────────────────────────────────────────────────
-          browser = mk {
-            name = "browser";
-            deps = [ pkgs.curl ];
-            text = browserPrelude + ''
-              _parse_browser_args "$@"
-              _refuse_if_port_busy
-              _prepare_profile
-              echo "[browser] $BROWSER_BIN"
-              echo "[browser] profile $PROFILE (project-local - your real browsing is untouched)"
-              echo "[browser] CDP on http://127.0.0.1:$PORT"
-              exec "$BROWSER_BIN" "''${CHROME_ARGS[@]}" "''${URLS[@]}"
-            '';
-          };
-
-          watch = mk {
-            name = "watch";
-            deps = [
-              nodejs
-              pkgs.curl
-            ];
-            text = browserPrelude + ''
-              _parse_browser_args "$@"
-              _prepare_profile
-
-              if curl -fsS --max-time 1 "http://127.0.0.1:$PORT/json/version" >/dev/null 2>&1; then
-                echo "[watch] attaching to the browser already on $PORT (it stays up when this exits)"
-              else
-                mkdir -p "$PRJ/.nix-browser"
-                "$BROWSER_BIN" "''${CHROME_ARGS[@]}" "''${URLS[@]}" \
-                  >"$PRJ/.nix-browser/chrome.log" 2>&1 &
-                owned=$!
-                # This command OWNS the browser it started, so Ctrl-C takes it
-                # down too. A browser we merely attached to is left alone.
-                # shellcheck disable=SC2064
-                trap "kill $owned 2>/dev/null || true" EXIT
-                for _ in $(seq 1 60); do
-                  curl -fsS --max-time 1 "http://127.0.0.1:$PORT/json/version" >/dev/null 2>&1 && break
-                  sleep 0.25
-                done
-              fi
-
-              if ! curl -fsS --max-time 1 "http://127.0.0.1:$PORT/json/version" >/dev/null 2>&1; then
-                echo "[watch] the browser never opened its CDP port; see $PRJ/.nix-browser/chrome.log" >&2
-                exit 1
-              fi
-
-              node scripts/userscript-watch.mjs --port "$PORT" ''${HOT:+--hot} ''${SCROLL:+--scroll}
-            '';
-          };
-
-          # Does the script actually work on THIS page? Runs in the browser the
-          # watch loop already keeps up, and drives a real wheel event so lazy,
-          # viewport-gated content is measured rather than guessed at.
-          verify = mk {
-            name = "verify";
-            deps = [ nodejs ];
-            text = ''
-              if [ $# -lt 1 ]; then
-                echo "usage: verify <url> [--expect <html-attribute>] [--no-scroll]" >&2
-                echo "              [--gate '<gridSel>,<unitHref>'] [--gate-thresholds u,r,s] [--port N]" >&2
-                echo "   eg: nix run .#verify -- https://example.com/ --expect data-nix-example" >&2
-                echo "       nix run .#verify -- <url> --expect data-ph-thumbwall \\" >&2
-                echo "             --gate 'ul.videos,/view_video.php'" >&2
-                exit 2
-              fi
-              exec node scripts/userscript-verify.mjs "$@"
-            '';
-          };
-
-          # The supervisor behind the Claude Code hooks, exposed so a person can
-          # drive it too. `ensure` is deliberately NOT an app: starting the loop
-          # by hand is what `watch` is for, and a command that silently declines
-          # would be a confusing thing to type.
-          watch-status = mk {
-            name = "watch-status";
-            deps = [ nodejs ];
-            text = "node scripts/watch-daemon.mjs status";
-          };
-
-          watch-stop = mk {
-            name = "watch-stop";
-            deps = [ nodejs ];
-            text = "node scripts/watch-daemon.mjs stop";
-          };
-
-          browser-bump = mk {
-            name = "browser-bump";
-            deps = [
-              pkgs.curl
-              pkgs.jq
-            ];
-            text = ''
-              # NETWORK. Prints what nix/chrome-for-testing.nix should say next.
-              api=https://googlechromelabs.github.io/chrome-for-testing/last-known-good-versions.json
-              if [ $# -eq 0 ]; then
-                echo "last known good Chrome for Testing:"
-                curl -fsS "$api" | jq -r '.channels | to_entries[] | "  \(.key)\t\(.value.version)"'
-                echo
-                echo "then: nix run .#browser-bump -- <version>"
-                exit 0
-              fi
-              v="$1"
-              echo "  version = \"$v\";"
-              for plat in mac-arm64 mac-x64 linux64; do
-                url="https://storage.googleapis.com/chrome-for-testing-public/$v/$plat/chrome-$plat.zip"
-                if ! h=$(nix-prefetch-url --type sha256 "$url" 2>/dev/null | tail -1); then
-                  echo "  # $plat: FAILED to fetch $url" >&2
-                  continue
-                fi
-                sri=$(nix hash convert --hash-algo sha256 --to sri "$h")
-                printf '  # %-9s hash = "%s";\n' "$plat" "$sri"
-              done
-              echo
-              echo "paste into nix/chrome-for-testing.nix, then: nix run .#browser"
-            '';
-          };
-
           toolkit = mk {
             name = "toolkit";
             text = ''
@@ -916,14 +676,6 @@
                 publish-check <script>  every pre-publish condition, as a checklist
                 new-script <name>       scaffold a script + listing with the design rules
 
-                browser [--violentmonkey]  pinned Chromium, project-local profile
-                watch [--hot] [--scroll] ^ plus live injection on save
-                verify <url>            did it run, throw, arm and hydrate?
-                  --gate 'sel,href'     ...and if it declined, WHICH signal failed
-                browser-bump [version]  refresh the pinned Chrome for Testing
-                watch-status            is the supervised watch loop up?
-                watch-stop              stop the loop the Claude hooks keep alive
-
                 diagram [file]          mermaid -> ASCII for listings/*.md (<=80 cols)
                 link-check              lychee over every *.md (NETWORK)
                 deps                    point ./node_modules at the flake-pinned tree
@@ -967,7 +719,7 @@
               touch "$out"
             '';
         in
-        removeAttrs self.packages.${system} [ "chromium" ]
+        self.packages.${system}
         // {
           # eslint-plugin-userscripts resolves from eslint.config.mjs's own
           # directory, so node_modules has to sit beside it — NODE_PATH is
diff --git a/nix/chrome-for-testing.nix b/nix/chrome-for-testing.nix
deleted file mode 100644
index e64c71a..0000000
--- a/nix/chrome-for-testing.nix
+++ /dev/null
@@ -1,112 +0,0 @@
-# Chrome for Testing — a pinned, non-self-updating Chromium build.
-#
-# WHY NOT `pkgs.chromium`: it is LINUX-ONLY in nixpkgs (meta.platforms carries
-# no darwin entry, checked 2026-09-29), and this repository is maintained on
-# aarch64-darwin. WHY NOT the browser already in /Applications: it auto-updates,
-# so "the version I measured against" is not a thing you can write down.
-#
-# Chrome for Testing is Google's build FOR automation: every version stays
-# hosted at its own immutable URL forever, it never self-updates, and it keeps
-# --load-extension working. nixpkgs' own `chromedriver` already sources from
-# this bucket on darwin and marks it free, which is the precedent followed here.
-#
-# It is Chrome-branded rather than Chromium-branded. The engine is the same one;
-# what differs is the branding and the absence of an updater. Say "Chrome for
-# Testing <version>" in a measurement note, not "Chromium".
-#
-# To bump: `nix run .#browser-bump` prints the current channel versions and the
-# three hashes, ready to paste. By hand:
-#   curl -s https://googlechromelabs.github.io/chrome-for-testing/last-known-good-versions.json
-#   nix-prefetch-url --type sha256 https://storage.googleapis.com/chrome-for-testing-public/<v>/<plat>/chrome-<plat>.zip
-#   nix hash convert --hash-algo sha256 --to sri <base32>
-{
-  lib,
-  stdenv,
-  fetchurl,
-  unzip,
-}:
-let
-  version = "154.0.8037.57"; # Stable channel, last known good 2026-09-29
-
-  # Google ships mac-arm64, mac-x64 and linux64 — and NOT aarch64-linux. The
-  # flake falls back to pkgs.chromium there, which nixpkgs does build.
-  platforms = {
-    aarch64-darwin = {
-      slug = "mac-arm64";
-      hash = "sha256-Dms0OUacG4uVsuiccuop968A+ywoqIeDWKC2ACttOmQ=";
-    };
-    x86_64-darwin = {
-      slug = "mac-x64";
-      hash = "sha256-9sDf9GYvH/sB9j+d44iOqV5MY0hwqLn1Xm0iCLopqKk=";
-    };
-    x86_64-linux = {
-      slug = "linux64";
-      hash = "sha256-zu4pcgdNRB6nxLqLzA6qt35+h2gPZlPXPTBlhR/hAwI=";
-    };
-  };
-
-  plat =
-    platforms.${stdenv.hostPlatform.system}
-      or (throw "chrome-for-testing: Google publishes no build for ${stdenv.hostPlatform.system}");
-in
-stdenv.mkDerivation {
-  pname = "chrome-for-testing";
-  inherit version;
-
-  src = fetchurl {
-    url = "https://storage.googleapis.com/chrome-for-testing-public/${version}/${plat.slug}/chrome-${plat.slug}.zip";
-    inherit (plat) hash;
-  };
-
-  nativeBuildInputs = [ unzip ];
-  sourceRoot = "chrome-${plat.slug}";
-  dontConfigure = true;
-  dontBuild = true;
-  dontFixup = true; # the bundle is signed; rewriting it invalidates that
-
-  installPhase =
-    if stdenv.hostPlatform.isDarwin then
-      ''
-        runHook preInstall
-        mkdir -p "$out/Applications" "$out/bin"
-        # cp -R, never -L: the .app's Frameworks are SYMLINKS into
-        # Versions/Current, and resolving them both doubles the size and
-        # breaks the signature.
-        cp -R "Google Chrome for Testing.app" "$out/Applications/"
-        app="$out/Applications/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing"
-        chmod +x "$app"
-
-        # An `exec` WRAPPER, never a symlink. Chrome resolves its Framework
-        # through @executable_path, which macOS takes from the path the process
-        # was launched as — a symlink at $out/bin/chrome makes that $out/bin,
-        # and the framework lookup then fails with a three-line dlopen error
-        # naming a path that does not exist (measured 2026-09-29). `exec`
-        # replaces the process, so @executable_path becomes the .app's own
-        # MacOS directory, which is the only place the Framework is.
-        cat > "$out/bin/chrome" <<EOF
-        #!/bin/sh
-        exec "$app" "\$@"
-        EOF
-        sed -i 's|^        ||' "$out/bin/chrome"
-        chmod +x "$out/bin/chrome"
-        runHook postInstall
-      ''
-    else
-      ''
-        runHook preInstall
-        mkdir -p "$out/opt/chrome" "$out/bin"
-        cp -R . "$out/opt/chrome"
-        chmod +x "$out/opt/chrome/chrome"
-        ln -s "$out/opt/chrome/chrome" "$out/bin/chrome"
-        runHook postInstall
-      '';
-
-  meta = {
-    description = "Chrome for Testing — a pinned, non-self-updating Chromium build";
-    homepage = "https://developer.chrome.com/blog/chrome-for-testing";
-    license = lib.licenses.unfree;
-    mainProgram = "chrome";
-    platforms = lib.attrNames platforms;
-    sourceProvenance = [ lib.sourceTypes.binaryNativeCode ];
-  };
-}
diff --git a/nix/violentmonkey.nix b/nix/violentmonkey.nix
deleted file mode 100644
index 5a9ff70..0000000
--- a/nix/violentmonkey.nix
+++ /dev/null
@@ -1,38 +0,0 @@
-# Violentmonkey, unpacked for `--load-extension`.
-#
-# This is the lane that verifies a script the way a READER runs it: a real
-# install in a real userscript manager, with the manager's own update path and
-# its "track local file" watcher. The CDP lane in `nix run .#watch` is faster
-# and fully automatic, but it is an injection — faithful for these scripts only
-# because every one of them is `@grant none`.
-#
-# The mv3 asset is the Chrome one. `Violentmonkey-webext-*.zip` is Firefox's and
-# `*-mv2-*.crx` is a manifest V2 build Chrome 139+ no longer runs.
-#
-# To bump: change `version`, then — note --unpack, which is NOT optional here.
-# fetchzip hashes the UNPACKED tree, so a plain `nix-prefetch-url` gives the
-# hash of the .zip and the build fails with a mismatch (measured 2026-09-29).
-#   nix-prefetch-url --unpack https://github.com/violentmonkey/violentmonkey/releases/download/v<v>/Violentmonkey-mv3-v<v>.zip
-#   nix hash convert --hash-algo sha256 --to sri <base32>
-{
-  lib,
-  fetchzip,
-}:
-let
-  version = "2.49.0";
-in
-fetchzip {
-  name = "violentmonkey-${version}";
-  url = "https://github.com/violentmonkey/violentmonkey/releases/download/v${version}/Violentmonkey-mv3-v${version}.zip";
-  hash = "sha256-jeIaytwDzN0Q+Lg+K19HWKZlTzEzBPiUjJy6M+H1kZc=";
-  # The zip is FLAT — manifest.json sits at the root, with no wrapping
-  # directory to strip. stripRoot's default of true would fail the unpack.
-  stripRoot = false;
-
-  meta = {
-    description = "Violentmonkey userscript manager, unpacked for --load-extension";
-    homepage = "https://violentmonkey.github.io/";
-    license = lib.licenses.mit;
-    platforms = lib.platforms.all;
-  };
-}
diff --git a/scripts/cdp.mjs b/scripts/cdp.mjs
deleted file mode 100644
index 06fca48..0000000
--- a/scripts/cdp.mjs
+++ /dev/null
@@ -1,91 +0,0 @@
-// The two pieces of DevTools Protocol plumbing that more than one tool here
-// needs. Kept small on purpose: everything else stays in its own command.
-//
-// WHY wheelUntilSettled EXISTS. `window.scrollTo` is the scroll-shaped version
-// of `el.click()`: it moves a number, and a page that scrolls an inner element
-// never hears about it. leolist.cc sets `html { overflow: hidden }` and scrolls
-// its listing column, so scrollTo left scrollY at 0 through six attempts while
-// an IntersectionObserver waited for a scroll that never happened — and a
-// filmstrip of 759 photos measured as ZERO (2026-09-29). A dispatched wheel
-// event goes through the compositor and hits whatever the real scroller is.
-//
-// This repository's own rule, applied to scrolling: geometry proves a control
-// is PRESENT, never that it WORKS, and only a trusted event proves the latter.
-
-/** Open a CDP websocket and return { send, close, on }. */
-export async function connect(wsUrl) {
-  const ws = new WebSocket(wsUrl);
-  await new Promise((resolve, reject) => {
-    ws.addEventListener('open', resolve, { once: true });
-    ws.addEventListener('error', reject, { once: true });
-  });
-
-  let seq = 0;
-  const pending = new Map();
-  const listeners = [];
-  ws.addEventListener('message', (ev) => {
-    const msg = JSON.parse(ev.data);
-    if (msg.id && pending.has(msg.id)) {
-      const { resolve, reject } = pending.get(msg.id);
-      pending.delete(msg.id);
-      msg.error ? reject(new Error(msg.error.message)) : resolve(msg.result);
-      return;
-    }
-    for (const fn of listeners) fn(msg);
-  });
-
-  const send = (method, params = {}, sessionId) =>
-    new Promise((resolve, reject) => {
-      const id = ++seq;
-      pending.set(id, { resolve, reject });
-      ws.send(JSON.stringify(sessionId ? { id, method, params, sessionId } : { id, method, params }));
-    });
-
-  return { send, on: (fn) => listeners.push(fn), close: () => ws.close() };
-}
-
-/**
- * Drive the page's REAL scroller with wheel events until nothing new appears.
- *
- * `measure` is a JS expression returning a number that grows as lazy content
- * hydrates. Scrolling stops once it has been unchanged for `stableRounds`
- * rounds, so a short page costs a couple of seconds and a long one keeps going
- * — rather than a fixed count that is always wrong in one direction.
- *
- * `maxRounds` is the honesty valve, not a target: the result carries
- * `settled: false` when it ran out, so a caller can say "still growing" rather
- * than report a number it knows is short. A 100-row leolist index was still
- * growing at 40 rounds of 800px (2026-09-29), which is why `verify` asks for
- * far more than the default and `watch --scroll` deliberately asks for less —
- * one is a check, the other is a refresh you pay for on every save.
- */
-export async function wheelUntilSettled(
-  send,
-  sessionId,
-  { measure, maxRounds = 40, deltaY = 1000, settleMs = 600, stableRounds = 4, x = 600, y = 400 } = {},
-) {
-  const read = async () => {
-    const r = await send('Runtime.evaluate', { expression: measure, returnByValue: true }, sessionId);
-    return Number(r?.result?.value) || 0;
-  };
-
-  let last = await read();
-  const first = last;
-  let stable = 0;
-  let rounds = 0;
-
-  while (rounds < maxRounds && stable < stableRounds) {
-    await send(
-      'Input.dispatchMouseEvent',
-      { type: 'mouseWheel', x, y, deltaX: 0, deltaY, pointerType: 'mouse' },
-      sessionId,
-    );
-    await new Promise((r) => setTimeout(r, settleMs));
-    rounds += 1;
-    const now = await read();
-    stable = now === last ? stable + 1 : 0;
-    last = now;
-  }
-
-  return { rounds, before: first, after: last, settled: stable >= stableRounds };
-}
diff --git a/scripts/userscript-verify.mjs b/scripts/userscript-verify.mjs
deleted file mode 100644
index 652f111..0000000
--- a/scripts/userscript-verify.mjs
+++ /dev/null
@@ -1,323 +0,0 @@
-#!/usr/bin/env node
-// Verify a userscript on a real page, in the browser `nix run .#watch` keeps up.
-//
-//   node scripts/userscript-verify.mjs <url> [--expect <attr>] [--no-scroll]
-//                                          [--prefix nix-,nx-]
-//                                          [--gate '<gridSel>,<unitHref>']
-//
-// Four questions, in the order they matter:
-//
-//   1. Did the script RUN?    (its teardown global exists)
-//   2. Did it THROW?          (any exception while the page loaded)
-//   3. Did it ARM?            (a data-nix-* attribute on <html>)
-//   4. Did the lazy content actually HYDRATE?
-//
-// (3) is reported, never failed on unless you name the attribute you expect.
-// Declining to arm is this repository's contract — the homepage and an empty
-// category are meant to render stock. And "armed" is not one bit: leolist's
-// DARK THEME arms site-wide while the listings rebuild does not, so on the
-// homepage `data-nix-leolist-dark` is present and
-// `data-nix-leolist-listings-only` is absent, both correctly. A check for "any
-// data-nix-* attribute" passes there and tells you nothing — measured
-// 2026-09-29, and it is why this takes a NAME.
-// (1) and (2) are failures. So is a broken injected image.
-//
-// (4) IS WHY THIS COMMAND EXISTS. Measuring straight after load measures an
-// unhydrated page. leolist.cc gates its filmstrip on an IntersectionObserver
-// and scrolls an inner column, so a filmstrip of 759 photos read as ZERO until
-// a real wheel event drove the real scroller (2026-09-29). The wheel step is
-// not a nicety here; without it the answer is confidently wrong.
-//
-// --gate ANSWERS "WHY NOT?" WHEN A SCRIPT DECLINES. It replays a grid-gallery
-// gate signal by signal: how many grids the selector matches, and for each —
-// renders, child count, unit count, rows, organic share — then whether a pager
-// was found and whether it sits inside the winning grid.
-//
-// IT TAKES THE SELECTORS RATHER THAN KNOWING THEM. thumbwall alone has four
-// modules with four sets of constants, and not even the same variable names,
-// so a built-in copy would be stale the week after it was written. Read them
-// out of the script and pass them:
-//
-//   --gate 'ul.videos,/view_video.php'     (pornhub)
-//   --gate 'div.thumb-list,/videos/'       (xhamster)
-//
-// AND IF THE REPLICA DISAGREES WITH THE SCRIPT, THE REPLICA IS WRONG. A gate
-// reporting "all signals pass" while the script declines means the measurement
-// is off, not the script — which is exactly how three working thumbwall
-// modules got written up as broken (2026-09-29). Check the constants and the
-// --expect attribute before believing it.
-
-import { readdirSync, readFileSync } from 'node:fs';
-import { connect, wheelUntilSettled } from './cdp.mjs';
-
-const argv = process.argv.slice(2);
-const flag = (n) => argv.includes(n);
-const opt = (n, d) => { const i = argv.indexOf(n); return i === -1 ? d : argv[i + 1]; };
-const url = argv.find((a) => /^https?:\/\//.test(a));
-const PORT = Number(opt('--port', process.env.USERSCRIPTS_CDP_PORT || '9222'));
-const ROOT = process.env.PROJECT_ROOT || process.cwd();
-
-if (!url) {
-  console.error('usage: userscript-verify.mjs <url> [--expect <html-attribute>] [--no-scroll] [--port N]');
-  process.exit(2);
-}
-
-// THE MARKER NAMESPACE IS NOT ONE STRING, AND NOT EVEN ONE PER SCRIPT.
-// leolist writes `data-nix-leolist-*`. thumbwall writes a DIFFERENT namespace
-// per host module: `data-nx-*` (xnxx/xvideos), `data-ep-*` (eporner),
-// `data-xh-*` (xhamster), `data-ph-*` (pornhub). Checking one of them reports a
-// clean "not armed" on every host that uses another — which is how three of
-// five hosts were briefly written up as broken when they were not
-// (2026-09-29). Override with --prefix when a script adds a sixth.
-const PREFIXES = String(opt('--prefix', 'nix-,nx-,ep-,xh-,ph-'))
-  .split(',').map((p) => p.trim()).filter(Boolean);
-
-// Injected nodes are counted by ATTRIBUTE, not class: thumbwall marks the
-// site's own cards with `data-<ns>-card` and injects almost no classes of its
-// own. Class matching stays restricted to the two prefixes actually used as
-// class names, because `[class*="ph-"]` would match pornhub's own markup and
-// `xh-` would match xhamster's.
-const CLASS_PREFIXES = PREFIXES.filter((p) => p === 'nix-' || p === 'nx-');
-const attrTest = PREFIXES.map((p) => `n.indexOf('data-${p}') === 0`).join(' || ');
-const SCAN = `(function(){
-  var pre = ${JSON.stringify(PREFIXES.map((p) => `data-${p}`))};
-  var cls = ${JSON.stringify(CLASS_PREFIXES)};
-  var n = 0;
-  var all = document.getElementsByTagName('*');
-  for (var i = 0; i < all.length; i++) {
-    var el = all[i], hit = false;
-    for (var a = 0; a < el.attributes.length && !hit; a++) {
-      for (var j = 0; j < pre.length && !hit; j++) {
-        if (el.attributes[a].name.indexOf(pre[j]) === 0) hit = true;
-      }
-    }
-    if (!hit && el.className && typeof el.className === 'string') {
-      for (var k = 0; k < cls.length && !hit; k++) {
-        if (new RegExp('(^|\\s)' + cls[k]).test(el.className)) hit = true;
-      }
-    }
-    if (hit) n++;
-  }
-  return n;
-})()`;
-const imgSel = CLASS_PREFIXES.map((p) => `img[class*="${p}"]`).join(',') || 'img.__none__';
-
-const MARKERS = `(function(){
-  var imgs = Array.from(document.querySelectorAll('${imgSel}'));
-  return JSON.stringify({
-    url: location.href,
-    ran: Object.getOwnPropertyNames(window).filter(function(k){ return /^__nix.*Teardown$/.test(k); }),
-    armed: Array.from(document.documentElement.attributes).map(function(a){ return a.name; })
-             .filter(function(n){ return ${attrTest}; }),
-    injected: ${SCAN},
-    images: imgs.length,
-    decoded: imgs.filter(function(i){ return i.complete && i.naturalWidth > 0; }).length,
-    // An <img> with no src yet reports complete === true and naturalWidth 0,
-    // which is PENDING, not broken. Requiring a non-empty src is what stops
-    // this crying wolf at every element the script has created but not yet
-    // filled (measured 2026-09-29: 2 "broken" images that were simply empty).
-    broken: imgs.filter(function(i){
-      var src = i.getAttribute('src') || '';
-      return src !== '' && i.complete && i.naturalWidth === 0;
-    }).length,
-    pending: imgs.filter(function(i){
-      return (i.getAttribute('src') || '') === '' || !i.complete;
-    }).length
-  });
-})()`;
-
-// Grows as lazy content hydrates; the wheel step stops when it stops growing.
-const MEASURE = `${SCAN} + document.querySelectorAll('${imgSel}').length`;
-
-let version;
-try {
-  version = await (await fetch(`http://127.0.0.1:${PORT}/json/version`)).json();
-} catch {
-  console.error(`no browser on :${PORT} — start one with 'nix run .#watch'.`);
-  process.exit(1);
-}
-
-const { send, on, close } = await connect(version.webSocketDebuggerUrl);
-const { targetId } = await send('Target.createTarget', { url: 'about:blank' });
-const { sessionId } = await send('Target.attachToTarget', { targetId, flatten: true });
-
-// An injected script has NO source URL — it is `<anonymous>` to the debugger —
-// while the site's own scripts all have one. Without that split, a page's own
-// error is blamed on the userscript: eporner's video preview throws
-// "AbortError: The play() request was interrupted" on its own, and verify
-// failed the script for it (measured 2026-09-29).
-const thrown = [];
-const pageThrown = [];
-on((msg) => {
-  if (msg.sessionId !== sessionId) return;
-  if (msg.method !== 'Runtime.exceptionThrown') return;
-  const d = msg.params.exceptionDetails;
-  const frame = d.stackTrace?.callFrames?.[0];
-  const ours = !d.url && !frame?.url;
-  const line = (d.exception?.description || d.text || '').split('\n')[0];
-  (ours ? thrown : pageThrown).push(line);
-});
-
-await send('Page.enable', {}, sessionId);
-await send('Runtime.enable', {}, sessionId);
-await send('Page.navigate', { url }, sessionId);
-await new Promise((r) => setTimeout(r, Number(opt('--settle', '9000'))));
-
-const read = async () => JSON.parse(
-  (await send('Runtime.evaluate', { expression: MARKERS, returnByValue: true }, sessionId)).result.value,
-);
-
-// ── the gate replica ─────────────────────────────────────────────────────────
-
-const gateSpec = opt('--gate', null);
-const gateExpr = (gridSel, unitHref, [unitsMin, rowsMin, shareMin]) => `(function(){
-  var GRID_SEL = ${JSON.stringify(gridSel)}, UNIT_HREF = ${JSON.stringify(unitHref)};
-  var UNITS_MIN = ${unitsMin}, ROWS_MIN = ${rowsMin}, SHARE_MIN = ${shareMin};
-  var renders = function(el){ var cs = getComputedStyle(el);
-    if (cs.display === 'none' || cs.visibility === 'hidden') return false;
-    var r = el.getBoundingClientRect(); return r.width > 300 && r.height > 150; };
-  var isUnit = function(el){ return !!el.querySelector('a[href*="' + UNIT_HREF + '"]'); };
-  var rowsOf = function(el){ var ys = new Set();
-    for (var kid of el.children){ var r = kid.getBoundingClientRect(); if (r.height > 20) ys.add(Math.round(r.top/10)); }
-    return ys.size; };
-  var PAGE_TOKEN = /(?:[?&](?:p|page|from)=\\d+)|(?:\\/\\d{1,4}(?:\\/|$))|(?:-\\d{1,4}(?:\\/|$))/;
-  var pagedTargets = function(el){
-    var anchors = Array.from(el.querySelectorAll('a[href]'));
-    if (!anchors.length || anchors.length > 60) return null;
-    for (var a of anchors) if ((a.getAttribute('href')||'').includes(UNIT_HREF)) return null;
-    var seen = new Set();
-    for (var b of anchors){ var u; try { u = new URL(b.getAttribute('href')||'', location.href); } catch(e){ continue; }
-      var t = u.pathname + u.search; if (PAGE_TOKEN.test(t)) seen.add(t); }
-    return { total: anchors.length, targets: seen.size }; };
-  var PAGER_NAMED = '.pagination,[class*="pagin"],[class*="pager"],[class*="page-list"],[class*="load-more"]';
-  var named = 0, pager = null;
-  for (var el of document.querySelectorAll(PAGER_NAMED)) { named++;
-    var cs = getComputedStyle(el);
-    if (cs.display === 'none' || cs.visibility === 'hidden') continue;
-    if (el.getBoundingClientRect().height <= 4) continue;
-    var p = pagedTargets(el); if (p && p.targets >= 1) { pager = el; break; } }
-  var fallback = 0;
-  if (!pager) { for (var e2 of document.querySelectorAll('div,nav,ul,section')) {
-    var c2 = getComputedStyle(e2);
-    if (c2.display === 'none' || c2.visibility === 'hidden') continue;
-    if (e2.getBoundingClientRect().height <= 4) continue;
-    var p2 = pagedTargets(e2);
-    if (p2 && p2.targets >= 3 && p2.targets / p2.total >= 0.5) fallback++; } }
-  var grids = Array.from(document.querySelectorAll(GRID_SEL));
-  var rows = grids.slice(0, 8).map(function(g){
-    var kids = Array.from(g.children), units = kids.filter(isUnit);
-    var share = kids.length ? units.length / kids.length : 0;
-    return { renders: renders(g), kids: kids.length, units: units.length, rows: rowsOf(g),
-             share: +share.toFixed(2),
-             passes: renders(g) && kids.length >= UNITS_MIN && units.length >= UNITS_MIN
-                     && rowsOf(g) >= ROWS_MIN && share >= SHARE_MIN }; });
-  var best = null;
-  for (var g3 of grids) {
-    var k3 = Array.from(g3.children), u3 = k3.filter(isUnit);
-    var s3 = k3.length ? u3.length / k3.length : 0;
-    if (!renders(g3) || k3.length < UNITS_MIN || u3.length < UNITS_MIN) continue;
-    if (rowsOf(g3) < ROWS_MIN || s3 < SHARE_MIN) continue;
-    if (!best || u3.length > best.n) best = { el: g3, n: u3.length }; }
-  return JSON.stringify({
-    gridSelMatches: grids.length, grids: rows,
-    pagerNamedCandidates: named, pagerFound: !!pager, pagerFallbackCandidates: fallback,
-    pagerInsideGrid: (best && pager) ? best.el.contains(pager) : null,
-    unitHrefsOnPage: document.querySelectorAll('a[href*="' + UNIT_HREF + '"]').length,
-    verdict: !pager ? 'no pager found'
-      : !best ? 'no grid passes unit/row/share'
-      : best.el.contains(pager) ? 'pager sits INSIDE the winning grid'
-      : 'all signals pass' });
-})()`;
-
-const before = await read();
-let wheel = null;
-if (!flag('--no-scroll')) {
-  // Thorough: a verification that stops early reports a number it knows is
-  // short. The settle detector still exits in seconds on a page that has
-  // nothing lazy.
-  wheel = await wheelUntilSettled(send, sessionId, {
-    measure: MEASURE,
-    maxRounds: Number(opt('--max-rounds', '150')),
-  });
-  await new Promise((r) => setTimeout(r, 2000));
-}
-const after = await read();
-
-const scripts = readdirSync(ROOT)
-  .filter((f) => f.endsWith('.user.js'))
-  .map((f) => /^\/\/\s*@version\s+(\S+)/m.exec(readFileSync(`${ROOT}/${f}`, 'utf8'))?.[1] ?? '?');
-
-const ok = (b) => (b ? 'ok  ' : 'FAIL');
-const ran = after.ran.length > 0;
-const clean = thrown.length === 0;
-const noBroken = after.broken === 0;
-const expect = opt('--expect', null);
-const armedOk = !expect || after.armed.includes(expect);
-
-console.log(`verify ${after.url}`);
-console.log(`  scripts in tree   ${scripts.join(', ')}   markers ${PREFIXES.join(' ')}`);
-console.log(`  ${ok(ran)}  ran               ${after.ran.join(', ') || '(no teardown global — the script never executed)'}`);
-console.log(`  ${ok(clean)}  threw nothing     ${thrown.slice(0, 3).join(' | ') || 'no exception from the injected script'}`);
-if (pageThrown.length) {
-  console.log(`  note  page's own errors ${pageThrown.length} (not the script's): ${pageThrown[0].slice(0, 80)}`);
-}
-console.log(
-  `  ${expect ? ok(armedOk) : 'note'}  armed             ` +
-    (after.armed.join(', ') ||
-      `no ${PREFIXES.map((x) => `data-${x}*`).join(' / ')} attribute — stock, which is the contract unless you expected otherwise`),
-);
-if (expect && !armedOk) console.log(`        expected          ${expect}`);
-if (wheel) {
-  console.log(
-    `  note  wheel-scrolled    ${wheel.rounds} round(s), hydrated ${wheel.before} -> ${wheel.after}` +
-      (wheel.settled ? ' (settled)' : ' — STILL GROWING at --max-rounds, the count below is a floor'),
-  );
-} else {
-  console.log('  note  wheel-scrolled    SKIPPED (--no-scroll) — lazy content is NOT measured');
-}
-console.log(`  note  injected nodes    ${before.injected} before scroll, ${after.injected} after`);
-console.log(
-  `  ${ok(noBroken)}  images            ${after.images} total, ${after.decoded} decoded, ` +
-    `${after.broken} broken, ${after.pending} pending`,
-);
-
-if (gateSpec) {
-  const [gridSel, unitHref] = gateSpec.split(',').map((x) => x.trim());
-  const th = String(opt('--gate-thresholds', '4,2,0.5')).split(',').map(Number);
-  if (!gridSel || !unitHref) {
-    console.log("  note  gate              --gate needs '<gridSelector>,<unitHref>' read from the script's own source");
-  } else {
-    const g = JSON.parse(
-      (await send('Runtime.evaluate', { expression: gateExpr(gridSel, unitHref, th), returnByValue: true }, sessionId))
-        .result.value,
-    );
-    console.log(`  note  gate              ${gridSel} + ${unitHref}  (units>=${th[0]} rows>=${th[1]} share>=${th[2]})`);
-    console.log(`        verdict           ${g.verdict}`);
-    console.log(`        grids matched     ${g.gridSelMatches}, passing ${g.grids.filter((r) => r.passes).length}`);
-    for (const r of g.grids) {
-      console.log(
-        `          ${r.passes ? 'pass' : '    '}  renders=${r.renders} kids=${r.kids} units=${r.units}` +
-          ` rows=${r.rows} share=${r.share}`,
-      );
-    }
-    console.log(
-      `        pager             found=${g.pagerFound} (named ${g.pagerNamedCandidates},` +
-        ` fallback ${g.pagerFallbackCandidates}), insideGrid=${g.pagerInsideGrid}`,
-    );
-    console.log(`        unit links        ${g.unitHrefsOnPage} matching ${unitHref}`);
-    if (g.verdict === 'all signals pass' && after.armed.length === 0) {
-      console.log('        SUSPECT THE REPLICA, NOT THE SCRIPT — a gate that passes while the');
-      console.log('        script declines means wrong constants or a wrong --expect attribute.');
-    }
-  }
-}
-
-const pass = ran && clean && noBroken && armedOk;
-
-// Close the tab on success, LEAVE IT OPEN on failure. A failed verification is
-// the one time you want the page still sitting there to poke at.
-if (pass) await send('Target.closeTarget', { targetId });
-else console.log(`  note  tab left open    ${after.url}`);
-
-close();
-process.exit(pass ? 0 : 1);
diff --git a/scripts/userscript-watch.mjs b/scripts/userscript-watch.mjs
deleted file mode 100644
index 3a9788d..0000000
--- a/scripts/userscript-watch.mjs
+++ /dev/null
@@ -1,393 +0,0 @@
-#!/usr/bin/env node
-// Live userscript injection over the Chrome DevTools Protocol.
-//
-// WHAT IT IS. A userscript manager copies a file into extension storage and
-// runs it at document-start on every matching page. This does the same thing
-// through CDP: `Page.addScriptToEvaluateOnNewDocument`, gated in-page by the
-// script's own @match patterns. Save the file, the page comes back with the new
-// code — no manager, no clicks, no install.
-//
-// WHY THAT IS FAITHFUL HERE, AND WHEN IT STOPS BEING. CLAUDE.md § "Injecting is
-// not installing" lists what a `Runtime.evaluate` injection gets wrong. The two
-// that matter are handled:
-//
-//   * @run-at document-start. addScriptToEvaluateOnNewDocument runs BEFORE any
-//     page script on every navigation, which is exactly what a manager does —
-//     unlike evaluating into an already-painted page, where a document-start
-//     gate has nothing left to gate.
-//   * @match / @noframes. Compiled into the wrapper and evaluated in-page
-//     against location.href, so every other page is left stock, as installed.
-//
-// What it still cannot do is provide manager APIs. Every script in this
-// repository is `@grant none`, so nothing is missing — and if one ever grants
-// something, this refuses to inject it rather than pretend.
-//
-// A SAVE THAT DOES NOT PARSE NEVER REACHES THE PAGE. `node --check` runs first;
-// on failure the error is printed and the browser keeps the last good version.
-
-import { execFileSync } from 'node:child_process';
-import { readFileSync, readdirSync, watch } from 'node:fs';
-import { basename, join } from 'node:path';
-import { wheelUntilSettled } from './cdp.mjs';
-
-const argv = process.argv.slice(2);
-const flag = (name) => argv.includes(name);
-const opt = (name, fallback) => {
-  const i = argv.indexOf(name);
-  return i === -1 ? fallback : argv[i + 1];
-};
-
-const ROOT = process.env.PROJECT_ROOT || process.cwd();
-const PORT = Number(opt('--port', process.env.USERSCRIPTS_CDP_PORT || '9222'));
-const HOT = flag('--hot');
-const ONCE = flag('--once');
-const SCROLL = flag('--scroll');
-const explicit = argv.filter((a, i) => !a.startsWith('--') && argv[i - 1] !== '--port');
-
-const log = (...m) => console.log(`[watch] ${m.join(' ')}`);
-const warn = (...m) => console.warn(`[watch] ${m.join(' ')}`);
-
-// ── userscript -> injectable bundle ──────────────────────────────────────────
-
-const META_RE = /\/\/ ==UserScript==([\s\S]*?)\/\/ ==\/UserScript==/;
-
-/** Chrome match pattern -> RegExp. `*://`, `*.host` and `*` in the path only. */
-function matchToRegExp(pattern) {
-  const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const m = /^(\*|https?|file|ftp):\/\/([^/]*)(\/.*)$/.exec(pattern);
-  if (!m) return null;
-  const [, scheme, host, path] = m;
-  const s = scheme === '*' ? 'https?' : scheme;
-  let h;
-  if (host === '*') h = '[^/]*';
-  // `*.example.com` matches example.com AND any subdomain — Chrome's rule, and
-  // the reason thumbwall can list `*.xhamster.com` without a bare entry.
-  else if (host.startsWith('*.')) h = `(?:[^/]*\\.)?${esc(host.slice(2))}`;
-  else h = esc(host);
-  const p = path.split('*').map(esc).join('[\\s\\S]*');
-  return new RegExp(`^${s}://${h}${p}$`);
-}
-
-function parse(file) {
-  const source = readFileSync(file, 'utf8');
-  const block = META_RE.exec(source);
-  if (!block) throw new Error(`${basename(file)}: no metadata block`);
-
-  const keys = new Map();
-  for (const line of block[1].split('\n')) {
-    const m = /^\s*\/\/\s*@(\S+)\s*(.*)$/.exec(line);
-    if (!m) continue;
-    if (!keys.has(m[1])) keys.set(m[1], []);
-    keys.get(m[1]).push(m[2].trim());
-  }
-
-  const grants = (keys.get('grant') || []).filter((g) => g && g !== 'none');
-  const patterns = (keys.get('match') || []).concat(keys.get('include') || []);
-  const regexes = patterns.map(matchToRegExp).filter(Boolean);
-  const body = source.slice(block.index + block[0].length);
-
-  // The gate is compiled INTO the payload rather than decided here, because a
-  // target's URL at attach time is usually about:blank — the real URL only
-  // exists in the page, at the moment the script runs.
-  const wrapped = `(function(){
-  if (${keys.has('noframes') ? 'true' : 'false'} && window.top !== window.self) return;
-  var __m = [${regexes.map((r) => `new RegExp(${JSON.stringify(r.source)})`).join(',')}];
-  if (__m.length && !__m.some(function(r){ return r.test(location.href); })) return;
-  var __run = function(){
-${body}
-  };
-  // addScriptToEvaluateOnNewDocument runs EARLIER than a manager's
-  // document-start. Measured 2026-09-29 on leolist.cc: at injection time
-  // documentElement is null, document.childNodes.length is 0 and readyState is
-  // "loading" — the document is completely empty. A Chrome content script at
-  // document_start runs a moment later, once the parser has created <html> and
-  // before any other DOM, and a userscript may rely on that; this repository's
-  // do (leolist-listings-only touches documentElement.dataset immediately and
-  // died with "Cannot read properties of null"). So wait for <html> rather than
-  // running earlier than the thing being reproduced.
-  if (document.documentElement) { __run(); return; }
-  var __o = new MutationObserver(function(){
-    if (!document.documentElement) return;
-    __o.disconnect();
-    __run();
-  });
-  __o.observe(document, { childList: true });
-})();`;
-
-  return {
-    file,
-    name: basename(file),
-    scriptName: (keys.get('name') || ['?'])[0],
-    version: (keys.get('version') || ['?'])[0],
-    grants,
-    patterns,
-    wrapped,
-  };
-}
-
-/** Grows as lazy, viewport-gated content hydrates. Drives when to stop scrolling. */
-// Both marker namespaces this repository uses: leolist writes `nix-*`,
-// thumbwall writes `nx-*`. One prefix would silently measure nothing on the
-// other script's sites.
-const HYDRATION_MEASURE =
-  `document.querySelectorAll('[class*="nix-"],[class*="nx-"]').length` +
-  ` + document.querySelectorAll('img[class*="nix-"],img[class*="nx-"]').length`;
-
-/** Teardown every live copy, using this repository's own `__nix*Teardown` convention. */
-const TEARDOWN_SWEEP = `(function(){var n=0;
-  for (var k of Object.getOwnPropertyNames(window)) {
-    if (/^__nix.*Teardown$/.test(k) && typeof window[k] === 'function') {
-      try { window[k](); n++; } catch (e) { void e; }
-    }
-  }
-  return n; })();`;
-
-// ── CDP ──────────────────────────────────────────────────────────────────────
-
-let seq = 0;
-const pending = new Map();
-
-const send = (method, params = {}, sessionId) =>
-  new Promise((resolve, reject) => {
-    const id = ++seq;
-    pending.set(id, { resolve, reject });
-    ws.send(JSON.stringify(sessionId ? { id, method, params, sessionId } : { id, method, params }));
-  });
-
-/** sessionId -> { targetId, url, identifiers: Map<file, identifier> } */
-const sessions = new Map();
-
-/**
- * sessionId -> the in-flight promise that finishes registering our scripts on
- * it. Target.setAutoAttach RESOLVES BEFORE the attachedToTarget events it
- * causes have been handled, so anything that assumes "attached" also means
- * "registered" races the registration and loses: the reload lands first, the
- * page loads without the script, and the symptom is indistinguishable from a
- * dead selector (measured 2026-09-29).
- */
-const attachReady = new Map();
-
-async function registerAll(sessionId) {
-  const s = sessions.get(sessionId);
-  for (const b of bundles.values()) {
-    const { identifier } = await send(
-      'Page.addScriptToEvaluateOnNewDocument',
-      { source: b.wrapped },
-      sessionId,
-    );
-    s.identifiers.set(b.file, identifier);
-  }
-}
-
-/**
- * A page that was ALREADY LOADED when we attached has missed its
- * document-start. addScriptToEvaluateOnNewDocument only affects the NEXT
- * navigation, so registering against a live tab and stopping there leaves the
- * script registered and not running — which looks exactly like a dead selector
- * (measured 2026-09-29). Give every pre-existing page its document-start.
- */
-async function primeExistingPages() {
-  await Promise.allSettled([...attachReady.values()]);
-  for (const [sessionId, s] of sessions) {
-    if (!/^https?:/.test(s.url || '')) continue;
-    try {
-      if (HOT) {
-        await send('Runtime.evaluate', { expression: TEARDOWN_SWEEP, returnByValue: true }, sessionId);
-        for (const b of bundles.values()) {
-          await send('Runtime.evaluate', { expression: b.wrapped }, sessionId);
-        }
-        log(`primed ${s.url} in place`);
-      } else {
-        await send('Page.reload', {}, sessionId);
-        log(`primed ${s.url} by reload`);
-      }
-    } catch (e) {
-      warn(`prime ${s.url}: ${e.message}`);
-    }
-  }
-}
-
-async function reinstall(bundle) {
-  for (const [sessionId, s] of sessions) {
-    const old = s.identifiers.get(bundle.file);
-    try {
-      if (old) await send('Page.removeScriptToEvaluateOnNewDocument', { identifier: old }, sessionId);
-      const { identifier } = await send(
-        'Page.addScriptToEvaluateOnNewDocument',
-        { source: bundle.wrapped },
-        sessionId,
-      );
-      s.identifiers.set(bundle.file, identifier);
-
-      if (HOT) {
-        // Tear the old copy down, then run the new one in place. Fast, and it
-        // exercises the teardown contract on every save — but a document-start
-        // gate has nothing to gate on an already-painted page, so this is the
-        // mode for iterating, never the one you sign off on.
-        const n = await send('Runtime.evaluate', { expression: TEARDOWN_SWEEP, returnByValue: true }, sessionId);
-        await send('Runtime.evaluate', { expression: bundle.wrapped }, sessionId);
-        log(`hot-swapped into ${s.url || '(tab)'} (tore down ${n?.result?.value ?? 0})`);
-      } else {
-        // The faithful path: a reload runs the script at document-start, which
-        // is the only way the theme and pre-paint gates are actually exercised.
-        await send('Page.reload', {}, sessionId);
-        log(`reloaded ${s.url || '(tab)'}`);
-        if (SCROLL) {
-          // A reload lands at the top of an UNHYDRATED page. Anything gated on
-          // an IntersectionObserver — leolist's filmstrip, for one — is absent
-          // until something scrolls, and `window.scrollTo` does not count: the
-          // page scrolls an inner column and never hears about it. Drive the
-          // real scroller so the save you just made is actually on screen.
-          await new Promise((r) => setTimeout(r, 2500));
-          // Deliberately SHORTER than `verify`'s sweep: this runs on every
-          // save, so it refreshes what you are looking at rather than walking
-          // a hundred rows you are not.
-          const w = await wheelUntilSettled(send, sessionId, {
-            measure: HYDRATION_MEASURE,
-            maxRounds: 25,
-          });
-          log(`  hydrated ${w.before} -> ${w.after} over ${w.rounds} wheel round(s)`);
-        }
-      }
-    } catch (e) {
-      warn(`session ${sessionId}: ${e.message}`);
-    }
-  }
-}
-
-async function onAttached(sessionId, targetInfo) {
-  if (targetInfo.type !== 'page' || /^(devtools|chrome-extension):/.test(targetInfo.url)) {
-    // waitForDebuggerOnStart pauses EVERY new target, so one we do not inject
-    // into must still be released or that tab hangs on a blank page forever.
-    await send('Runtime.runIfWaitingForDebugger', {}, sessionId).catch(() => {});
-    return;
-  }
-  sessions.set(sessionId, { targetId: targetInfo.targetId, url: targetInfo.url, identifiers: new Map() });
-  try {
-    await send('Page.enable', {}, sessionId);
-    await registerAll(sessionId);
-  } catch (e) {
-    warn(`attach ${targetInfo.targetId}: ${e.message}`);
-  }
-  await send('Runtime.runIfWaitingForDebugger', {}, sessionId).catch(() => {});
-  log(`attached to ${targetInfo.url || '(new tab)'}`);
-}
-
-// ── bundles + watching ───────────────────────────────────────────────────────
-
-const bundles = new Map();
-
-function load(file) {
-  try {
-    execFileSync('node', ['--check', file], { cwd: ROOT, stdio: ['ignore', 'pipe', 'pipe'] });
-  } catch (e) {
-    warn(`${basename(file)} DOES NOT PARSE — keeping the last good version in the browser`);
-    console.warn(String(e.stderr || e.message).trim());
-    return null;
-  }
-  const b = parse(join(ROOT, basename(file)));
-  if (b.grants.length) {
-    warn(
-      `${b.name} declares @grant ${b.grants.join(' ')} — injection cannot provide manager APIs.`,
-      'Verify this one through the Violentmonkey lane: nix run .#browser -- --violentmonkey',
-    );
-    return null;
-  }
-  bundles.set(b.file, b);
-  return b;
-}
-
-function targetFiles() {
-  if (explicit.length) return explicit.map((f) => join(ROOT, basename(f)));
-  return readdirSync(ROOT)
-    .filter((f) => f.endsWith('.user.js'))
-    .sort()
-    .map((f) => join(ROOT, f));
-}
-
-// ── main ─────────────────────────────────────────────────────────────────────
-
-const endpoint = `http://127.0.0.1:${PORT}`;
-let version;
-try {
-  version = await (await fetch(`${endpoint}/json/version`)).json();
-} catch {
-  console.error(`[watch] nothing is answering CDP on ${endpoint} — start the browser first:`);
-  console.error('[watch]   nix run .#browser');
-  process.exit(1);
-}
-
-for (const f of targetFiles()) load(f);
-if (bundles.size === 0) {
-  console.error('[watch] no injectable userscript found');
-  process.exit(1);
-}
-log(`${version.Browser} on ${endpoint}`);
-for (const b of bundles.values()) log(`  ${b.name} ${b.version} — ${b.patterns.length} @match pattern(s)`);
-
-// Declared below its first textual reference in send(): that closure only
-// runs after the socket is open, so the temporal dead zone is never entered.
-const ws = new WebSocket(version.webSocketDebuggerUrl);
-
-ws.addEventListener('message', async (ev) => {
-  const msg = JSON.parse(ev.data);
-  if (msg.id && pending.has(msg.id)) {
-    const { resolve, reject } = pending.get(msg.id);
-    pending.delete(msg.id);
-    msg.error ? reject(new Error(msg.error.message)) : resolve(msg.result);
-    return;
-  }
-  if (msg.method === 'Target.attachedToTarget') {
-    const { sessionId, targetInfo } = msg.params;
-    attachReady.set(sessionId, onAttached(sessionId, targetInfo));
-  }
-  if (msg.method === 'Target.detachedFromTarget') {
-    sessions.delete(msg.params.sessionId);
-    attachReady.delete(msg.params.sessionId);
-  }
-  if (msg.method === 'Target.targetInfoChanged') {
-    for (const [, s] of sessions) {
-      if (s.targetId === msg.params.targetInfo.targetId) s.url = msg.params.targetInfo.url;
-    }
-  }
-});
-
-ws.addEventListener('close', () => {
-  log('browser closed');
-  process.exit(0);
-});
-
-await new Promise((resolve) => ws.addEventListener('open', resolve, { once: true }));
-await send('Target.setDiscoverTargets', { discover: true });
-// waitForDebuggerOnStart is what makes this document-start rather than
-// best-effort: a new tab is held before its first script runs, long enough to
-// register ours.
-await send('Target.setAutoAttach', { autoAttach: true, waitForDebuggerOnStart: true, flatten: true });
-
-// setAutoAttach attaches to every EXISTING target before it resolves, so by
-// here `sessions` holds the tabs that were already open — and those are exactly
-// the ones that missed their document-start.
-await primeExistingPages();
-
-if (ONCE) {
-  log('registered; --once, exiting');
-  process.exit(0);
-}
-
-log(
-  `watching ${ROOT} — ${HOT ? 'HOT swap (no reload)' : 'reload on save (faithful document-start)'}` +
-    (SCROLL ? ' + wheel-scroll to rehydrate' : ''),
-);
-
-let timer = null;
-watch(ROOT, (_event, filename) => {
-  if (!filename || !filename.endsWith('.user.js')) return;
-  if (explicit.length && !explicit.some((f) => basename(f) === filename)) return;
-  clearTimeout(timer);
-  timer = setTimeout(async () => {
-    const b = load(join(ROOT, filename));
-    if (!b) return;
-    log(`${filename} -> ${b.version}`);
-    await reinstall(b);
-  }, 120);
-});
diff --git a/scripts/watch-daemon.mjs b/scripts/watch-daemon.mjs
deleted file mode 100644
index 88ebe65..0000000
--- a/scripts/watch-daemon.mjs
+++ /dev/null
@@ -1,149 +0,0 @@
-#!/usr/bin/env node
-// Supervisor for `nix run .#watch`, so the live-injection loop is simply THERE.
-//
-//   ensure   start it if it is not already up, and say what happened
-//   status   one line: running / stopped / declined, and why
-//   stop     kill the browser and the watcher this daemon started
-//
-// Claude Code's hooks call `ensure` at session start, after any .user.js edit,
-// and at the end of a turn. It is idempotent and the already-running path costs
-// a pid check plus one loopback request, so calling it often is free.
-//
-// THE RULE THAT SHAPES THIS FILE: a hook must never inject scripts into a
-// browser it did not start. `watch` on its own will happily ATTACH to whatever
-// answers CDP on the port — which is the right behaviour when a person types
-// it, and the wrong behaviour entirely when a session-start hook fires and the
-// operator's own Chromium is sitting on 9222 with their real profile. So this
-// only ever claims a port it opened itself, tracked through a state file, and
-// declines with a reason otherwise.
-
-import { execFileSync, spawn } from 'node:child_process';
-import { existsSync, mkdirSync, openSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-const ROOT = process.env.CLAUDE_PROJECT_DIR || process.env.PROJECT_ROOT || process.cwd();
-const DIR = join(ROOT, '.nix-browser');
-const STATE = join(DIR, 'watch.json');
-const LOG = join(DIR, 'watch.log');
-const PORT = Number(process.env.USERSCRIPTS_CDP_PORT || 9222);
-const cmd = process.argv[2] || 'status';
-
-const say = (m) => console.log(`[watch-daemon] ${m}`);
-
-const readState = () => {
-  try {
-    return JSON.parse(readFileSync(STATE, 'utf8'));
-  } catch {
-    return null;
-  }
-};
-
-const pidAlive = (pid) => {
-  try {
-    // Signal 0 tests for existence and permission without delivering anything.
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-const portAnswers = async (port) => {
-  try {
-    const c = new AbortController();
-    const t = setTimeout(() => c.abort(), 1500);
-    const r = await fetch(`http://127.0.0.1:${port}/json/version`, { signal: c.signal });
-    clearTimeout(t);
-    return r.ok ? await r.json() : null;
-  } catch {
-    return null;
-  }
-};
-
-/** Running only when BOTH halves agree: our process is alive and its port answers. */
-async function probe() {
-  const st = readState();
-  if (!st || !pidAlive(st.pid)) return { running: false, state: st };
-  const v = await portAnswers(st.port ?? PORT);
-  return { running: Boolean(v), state: st, browser: v?.Browser };
-}
-
-function stop() {
-  const st = readState();
-  if (!st) return say('nothing to stop — no state file.');
-  try {
-    // Negative pid = the whole process group. `watch` is spawned detached, so it
-    // leads its own group and this takes the browser down with the watcher.
-    process.kill(-st.pid, 'SIGTERM');
-    say(`stopped pid group ${st.pid}`);
-  } catch {
-    say(`pid ${st.pid} was already gone`);
-  }
-  rmSync(STATE, { force: true });
-}
-
-async function ensure() {
-  if (process.env.USERSCRIPTS_WATCH === '0') return say('disabled by USERSCRIPTS_WATCH=0');
-
-  const scripts = readdirSync(ROOT).filter((f) => f.endsWith('.user.js'));
-  if (scripts.length === 0) return say('no .user.js in this repo — nothing to watch.');
-
-  const p = await probe();
-  if (p.running) {
-    return say(`already running — ${p.browser} on :${p.state.port}, ${scripts.length} script(s) live.`);
-  }
-
-  // Someone else owns the port. NEVER attach: that browser is not ours, and on
-  // 9222 it is most likely the operator's own Chromium with their real profile.
-  const squatter = await portAnswers(PORT);
-  if (squatter) {
-    return say(
-      `declined — ${squatter.Browser} already answers CDP on :${PORT} and this daemon did not start it. ` +
-        `Attach on purpose with 'nix run .#watch', or set USERSCRIPTS_CDP_PORT to a free port.`,
-    );
-  }
-
-  // Refuse to make session start wait on a 361 MB download. --offline builds
-  // what is local and fails rather than fetching, which is exactly the question
-  // being asked: can this start RIGHT NOW?
-  try {
-    execFileSync('nix', ['build', '--no-link', '--offline', '.#watch', '.#chromium'], {
-      cwd: ROOT,
-      stdio: ['ignore', 'ignore', 'ignore'],
-    });
-  } catch {
-    return say("browser not in the store yet — run 'nix run .#watch' once by hand (361 MB), then this takes over.");
-  }
-
-  mkdirSync(DIR, { recursive: true });
-  const out = openSync(LOG, 'a');
-  const child = spawn('nix', ['run', '.#watch', '--', '--port', String(PORT)], {
-    cwd: ROOT,
-    // detached + unref is what makes it OUTLIVE this hook. A hook process is
-    // short-lived and Claude Code reaps it; without its own process group the
-    // browser would die with the hook that started it.
-    detached: true,
-    stdio: ['ignore', out, out],
-  });
-  child.unref();
-  writeFileSync(STATE, JSON.stringify({ pid: child.pid, port: PORT, startedAt: new Date().toISOString() }));
-
-  for (let i = 0; i < 40; i++) {
-    const v = await portAnswers(PORT);
-    if (v) return say(`started — ${v.Browser} on :${PORT}, ${scripts.length} script(s) live on save.`);
-    if (!pidAlive(child.pid)) break;
-    await new Promise((r) => setTimeout(r, 250));
-  }
-  say(`started pid ${child.pid} but :${PORT} has not answered yet — see ${LOG}`);
-}
-
-if (cmd === 'stop') {
-  stop();
-} else if (cmd === 'ensure') {
-  await ensure();
-} else {
-  const p = await probe();
-  if (p.running) say(`running — ${p.browser} on :${p.state.port} (pid ${p.state.pid})`);
-  else if (existsSync(STATE)) say('stopped — stale state file, next ensure will restart it.');
-  else say('stopped.');
-}