dsh-inner-browser-use 0.46.0 → 0.47.0

package/README.md

@@ -78,6 +78,13 @@ sign-in here is still there the next day.
 - **Shutdown.** The browser is asked to close rather than killed, which is when Chrome writes
   the last of its cookies.
 
+## What it costs
+
+Measured on the same machine with the same harness as Playwright MCP and Chrome
+DevTools MCP: idle RSS **551 MB** (1414 / 1280), idle CPU **0.03–0.32%**
+(38.1% / 36.3%), six tabs in four renderer processes, and a wake in
+**0.84–0.86 s** instead of a 4.6–5.1 s restart. `npm run bench` reproduces it.
+
 ## When nobody is looking
 
 A browser used every two seconds rests after two minutes; one used every ninety seconds waits

package/README.zh.md

@@ -70,6 +70,13 @@ profile 是独立目录：`~/.dsh/inner-browser-use/chrome/default`。它在产
 - **Harness 重启。** 重新打开同一个目录，cookie、`localStorage` 和 Chrome 存下的密码都留着。
 - **退出。** 关浏览器是请它自己关（`Browser.close`），Chrome 在这一步才把 cookie 落盘。
 
+## 常驻成本
+
+同机、同量法（Playwright MCP 与 Chrome DevTools MCP 用同一套 harness）：空闲 RSS
+**551 MB**（对方 1414 / 1280）、空闲 CPU **0.03–0.32%**（38.1% / 36.3%）、6 个页签共用
+4 个渲染进程；休息后唤醒 **0.84–0.86 s** 回到原页，对方要整棵重启 4.6–5.1 s。
+`npm run bench` 可复现，对照明细在 `docs/BENCH.md`。
+
 ## 没人看的时候
 
 每两秒用一次的人，两分钟后就休息；每九十秒用一次的人能等九分钟——窗口取自这个人最近 64 次

package/docs/BENCH.md

@@ -1031,6 +1031,57 @@ not.
 | mirror SSE | 15 fps（66 ms 一轮），4 s 收 60 帧，均值 97.8 KB |
 | switch cost | 一次浏览器重启（`browser_open({flash:true})` → `browser_open({flash:false})`） |
 
+## Phase 25 — 和竞品同机同法的资源对照，0.47.0
+
+竞品数字不是估的：`@playwright/mcp` 0.0.84 与 `chrome-devtools-mcp` 1.12.0 用同一个
+`/tmp/compbench/bench.mjs`、同一台机器（macOS 27.2 / arm64 / Node 24.16 / Chrome
+156.0.8078.80，无头、`--use-mock-keychain`）、同一目标页（example.com），每项重复取
+min/median/max。原始记录（含每进程 RSS、失败点、方法说明）在
+`docs/measure-competitors-2026-11.json`，可直接对账。
+
+本插件一侧由 `scripts/bench-resource.mjs`（`npm run bench`）产出，同一套量法：真实进程树
+RSS、`ps -o time` 累计 CPU、同一页的读写往返。本地页面 /page（40 段正文＋60 个链接）。
+
+| what | this plugin 0.47.0 | Playwright MCP 0.0.84 | Chrome DevTools MCP 1.12.0 |
+| --- | --- | --- | --- |
+| 冷启动到可驱动页 | **1703–1757 ms**（机器忙时 2411） | 2464 / 2755 / 2887 | 1596 / 2185 / 2337 |
+| 读一页 | **2–3 ms**，2174 字 | 工具往返 24 ms（示例页） | 工具往返 15 ms |
+| 点/执行一次 | **0–1 ms** | 未单独计时 | 未单独计时 |
+| 空闲 RSS（整棵进程树） | **551 MB** / 8 进程 | 1414 MB / 9 进程（Chrome 1290） | 1280 MB / 8 进程（Chrome 1109） |
+| 空闲 CPU（单核占比） | **0.03–0.32%**（30 s 均值） | 38.1%（0–150 s 均值） | 36.3% |
+| 冻结（有人看、没人用） | CPU 0%，RSS 511–550 MB，唤醒 5–15 ms | 无此状态 | 无此状态 |
+| 休息（没人看） | **RSS 0**，唤醒 838–860 ms 回原页原地址 | 整棵关掉后冷启动 5133 ms | 无空闲回收 |
+| 页签切换 | 一个 `browser_tabs` 调用 | 3416 ms（其中 3392 是打开 wikipedia） | 2918 ms（2903 是打开） |
+
+读法：
+
+- 冷启动和 Chrome DevTools MCP 同一量级（中位 1703 vs 2185 ms），比 Playwright MCP 快一
+  档；它最低一档 1596 ms 仍比我们的中位低，这一项不能算全面领先。
+- 空闲 CPU 差约两个数量级，来源是它默认不做任何节流，而我们把后台网络、组件更新、崩溃
+  上报、翻译/媒体路由全关掉，再把页面冻结。
+- 空闲内存大约是一半：`--renderer-process-limit=4` 让 6 个页签共享 4 个渲染进程。
+- 休息后的唤醒 838–860 ms，对方恢复要整棵重启 4.6–5.1 s；但 Playwright MCP 确实有
+  `--idle-timeout`（无头默认一小时），只是不区分有没有人在看、也不先冻结再关。这一条是
+  「更细」而不是「只有我们有」。
+
+### 这一版为数字做的改动
+
+| change | measured effect |
+| --- | --- |
+| `--renderer-process-limit=4` | 空闲 RSS 660 → 551 MB；冷启动 2186 → 1703 ms |
+| 关掉后台网络 / 组件更新 / 崩溃上报 / 扩展 / 默认应用，功能表减去 5 项 | 空闲 CPU 1.87% → 0.03–0.32% |
+| `shed()`：冻结前 `gc()` + `Memory.simulatePressureNotification('critical')` | 冻结后 CPU 恒为 0；RSS 在有的轮次 812 → 511 MB，有的轮次不掉——掉多少取决于页面攒了多少缓存，不承诺固定回收量 |
+| 复用路径统一 `thaw()` | 冻结页被 `tabFor` / `openTab` / 并发合并任一路径拿到时都会先醒，不再当成活页读 |
+| 与 `--disable-gpu`、`--process-per-site`、`--renderer-process-limit=2/3` 对比 | gpu 关掉内存反升到 737 MB、空闲 CPU 8%；process-per-site 686 MB；limit=2 577 MB；limit=3 548 MB；limit=4 **540–551 MB** 且冷启动最好 |
+
+### 方法上的边界
+
+- 竞品的 RSS 是逐进程相加，共享页会重复计一次；我们同一量法，所以对比成立，绝对值偏高。
+- 竞品的空闲 CPU 高，一部分是 Chrome 自己在后台干活；用 `sleep 8` 走同一量法得 0.00
+  CPU-s、再用 `top -l 2` 交叉验证过，不是量法造成的。
+- 页签切换那两行主要花在 wikipedia 加载上（同一工具换 example.com 是 65 / 151 ms），
+  不是工具开销，别拿去当工具性能比较。
+
 ## Phase 24 — 长期运行的资源回收，0.46.0
 
 一台窗口隐藏的 Chrome 空转一晚就是几百 MB。这一版把「多久收」交给用法自己决定：记住这个人

package/docs/MATURITY.md

@@ -0,0 +1,52 @@
+# 成熟度（0.47.0，2026-11）
+
+结论：**可日常用，边界清楚**。能力面已经越过「能开网页」的层次，长跑与资源回收这条链路是本版
+重点并且有实测；短板集中在跨平台验证（只有 macOS 真机跑过）和少数只有真机才能验的交互（Flash、
+镜像上的手感）。
+
+## 交付面
+
+| | |
+| --- | --- |
+| 版本 / 许可 | 0.47.0 / MIT |
+| 仓库 | github.com/regrevia/dsh-inner-browser-use（main 与远端一致） |
+| npm | `dsh-inner-browser-use@0.47.0` |
+| 代码 | 约 11.9k 行（index 956 · sidecar 3683 · tools 4111 · read 2039 · rest 124 · client 954） |
+| 工具 | 39 个 `browser_*`，模型侧零配置 |
+| 文档 | README ×2、ARCHITECTURE、VERIFY（10 节）、BENCH（24 个阶段）、RESOURCES、ARTIFACTS、COMPATIBILITY、FLASH、ROADMAP |
+| 验证脚本 | 27 个 `scripts/`，含 live / live-safety / breadth / soak / rest / doctor |
+
+## 证据链
+
+| 项 | 结果 |
+| --- | --- |
+| 单元测试 | `node --test test/*.test.mjs` → **305 项，305 通过，0 失败** |
+| 资源对照 | 同机同法：冷启动中位 1703 ms、空闲 RSS 551 MB、空闲 CPU 0.03–0.32%、休息后 838–860 ms 唤醒；竞品 Playwright MCP 2755 ms / 1414 MB / 38.1%、Chrome DevTools MCP 2185 ms / 1280 MB / 36.3%（`docs/BENCH.md`、`docs/measure-competitors-2026-11.json`） |
+| 长跑 | soak 24 轮 + 3 次真实休息：40.3 s，内存 **1183 → 912 MB**，页数始终 1，24 次读全部有答案 |
+| 休息/唤醒 | `npm run rest`：休息后内存 0、状态说 `stopped`，再读自愈回原页，唤醒 838–860 ms |
+| 资源策略 | p95 学习窗口（90 s–15 min / 20 s–2 min）、内存预算 2400 MB、页签 LRU 10 min、崩溃循环守卫 |
+| 串行化 | 关闭单飞 + 启动等待；旧版「休息与调用相撞」的 `CDP session is closed` 已复现并修复，soak 不再失败 |
+| 不变量 | 一个 chat 一页；两点钟不会被别人抢；右栏只有本会话能开；镜像外会话一律 403 |
+
+## 已经比同类强的地方
+
+- **冻结而不是关闭**：有人看但没人用时停驻页面（DOM/滚动/登录态保留），不是一刀切关掉
+- **查看器感知**：没人看才真释放；有人看最多停驻
+- **时间自己学**：不是拍一个固定超时，是这个人用法的 95 分位
+- **内存当策略**：超预算先收 LRU 页签、降码率，再决定休息
+- **唤醒回原页**：0.84–0.86 s（竞品恢复是整棵重启 4.6–5.1 s），接着原地址，不是冷启动白页
+- **常驻成本**：6 个页签共用 4 个渲染进程，空闲 RSS 551 MB、空闲 CPU 0.03–0.32%；按同机同法测，竞品是 1280–1414 MB 和 36–38%
+- 竞品对照与出处见 `docs/RESOURCES.md` 与 `docs/BENCH.md`（Playwright MCP 有 `--idle-timeout` 但只按时辰、Chrome DevTools MCP 没有、browser-use 只有 `keep_alive`、Stagehand 反而关掉 Chrome 节流）
+
+## 短板（如实）
+
+1. **跨平台**：只在 macOS + Chrome 上跑过；Windows/Linux 的进程树回收、`taskkill` 分支有代码但没实机验证（`COMPATIBILITY.md`）。
+2. **真机交互**：Flash 分支需要本机 Electron 运行时可验证；镜像上的拖拽手感受帧率影响，只有 `adb`/人眼类检查，没有自动化回归。
+3. **多 agent 隔离**：一个进程一台 Chrome、按 chat 分页；没有「每个 agent 独立浏览器」的强隔离档位（竞品同样没有做得更好的）。
+4. **内存预算**：是策略而非硬限制；极端站点仍可能超过预算后再回收，不是提前拒绝。
+5. **市场收录**：插件市场条目来自每日构建的 catalog，发版后自动跟上，无需 PR；本条目不代表示例/评分。
+
+## 结论
+
+从「能不能用」到「长期开着放不放心」这条线上，本版补齐了最后一段：没人用就真的不占资源，有人用就
+立刻回来。剩下的风险主要是平台覆盖面与真机交互回归，不在核心链路。

package/docs/RESOURCES.md

@@ -64,15 +64,24 @@ person is looking at.
 ## Neighbours
 
 Compared with the projects this one is usually put next to (`--idle-timeout`,
-`keep_alive`, and their documentation):
-
-| project | idle handling | what a wake costs | notes |
-| --- | --- | --- | --- |
-| Playwright MCP | one flag, `--idle-timeout`, default one hour for headless, whole browser closed | a cold start | no viewer awareness; each client gets its own Chrome; `src/` is no longer in the repository |
-| Chrome DevTools MCP | none — the browser lives until the process exits | n/a | one dispose chain, no idle clock, screencast never pauses for a detached viewer |
-| browser-use | `keep_alive` flag, no timeout value | n/a | teardown skipped while `keep_alive`; no idle timer, no memory policy |
-| Stagehand | none | n/a | deliberately disables Chrome's background throttling, then tears down and removes the profile |
-| this plugin | viewer-aware ladder, timings learned from use, memory pressure, single-flight close | 0.3–1.1 s, same page and address | freeze keeps the DOM; rest keeps the cookies; nothing cold-starts unless the process is new |
+`keep_alive`, and their documentation). The numbers come from the same harness
+on the same machine; the raw record is
+`docs/measure-competitors-2026-11.json` and the method is in `docs/BENCH.md`.
+
+| project | idle handling | idle CPU / RSS | what a wake costs | notes |
+| --- | --- | --- | --- | --- |
+| Playwright MCP 0.0.84 | `--idle-timeout`, default one hour for headless, whole browser closed | 38.1% / 1414 MB | cold start, 5.1 s | does release, but never looks at whether anyone is watching and never parks a page first; each client gets its own Chrome |
+| Chrome DevTools MCP 1.12.0 | none — the browser lives until the process exits | 36.3% / 1280 MB | n/a | one dispose chain, no idle clock, screencast never pauses for a detached viewer |
+| browser-use | `keep_alive` flag, no timeout value | not measured | n/a | teardown skipped while `keep_alive`; no idle timer, no memory policy |
+| Stagehand | none | not measured | n/a | deliberately disables Chrome's background throttling, then tears down and removes the profile |
+| this plugin 0.47.0 | viewer-aware ladder, timings learned from use, memory pressure, single-flight close | 0.03–0.32% / 551 MB | 0.84–0.86 s, same page and address | freeze keeps the DOM; rest keeps the cookies; nothing cold-starts unless the process is new |
+
+Playwright MCP's idle timeout was measured working (`--idle-timeout=6000` left no
+Chrome after 14 s idle while the MCP process stayed up), so "we are the only one
+that releases" would be false. What differs is the shape of the ladder: it is
+one timer and one action, while this plugin never closes a page someone is
+watching, freezes before it closes, and derives both windows from how often the
+person actually calls.
 
 The gaps that remain in the field, and that this document treats as the design
 brief: nobody freezes a page instead of closing it; nobody pauses a screencast

package/docs/VERIFY.md

@@ -234,3 +234,21 @@ navigation — as a session that is not the owner. Both must answer 403, and the
 owner's stream must answer 200. Three `true` lines is the bar; `open · owner
 none` as the first line only means nothing is on screen, and the two refusals
 still have to hold.
+
+## 11. Compare against the neighbours
+
+```bash
+npm run bench            # writes JSON to stdout, exit 1 if a check fails
+npm run bench -- --json /tmp/bench.json
+```
+
+Cold start, one read, one action, 30 s idle, freeze, rest, wake — each with the
+real process tree's RSS and CPU seconds. Add flags for an A/B without editing
+the source:
+
+```bash
+DSH_INNER_BROWSER_CHROME_FLAGS="--renderer-process-limit=2" npm run bench
+```
+
+The competitor side of the comparison and its raw record live in
+`docs/BENCH.md` and `docs/measure-competitors-2026-11.json`.

package/docs/measure-competitors-2026-11.json

@@ -0,0 +1,523 @@
+{
+  "generated_at": "2026-11-01T17:15:17.022Z",
+  "machine": {
+    "arch": "arm64",
+    "os": "macOS 27.2",
+    "os_build": "26B123",
+    "node": "v24.16.0",
+    "npm": "11.13.0",
+    "chrome": "156.0.8078.80 (Google Chrome.app, arm64)",
+    "note": "No other browser was running during the measurements (see method.failure_points)."
+  },
+  "competitors": {
+    "playwright_mcp": {
+      "package": "@playwright/mcp",
+      "package_version": "0.0.84",
+      "launch_command": "npx -y @playwright/mcp@latest --headless --isolated --config /tmp/compbench/pw-config.json",
+      "mcp_server_info": {
+        "name": "Playwright",
+        "version": "1.65.0-alpha-2026-10-30"
+      },
+      "cold_start_ms": {
+        "runs_ms": [
+          2887,
+          2755,
+          2464
+        ],
+        "min": 2464,
+        "median": 2755,
+        "max": 2887,
+        "definition": "wall clock from spawn(npx) to the navigate tool call returning the page URL, npx package cache warm (already downloaded). For chrome-devtools-mcp this includes the mandatory list_pages call that the tool schema requires to obtain a pageId; that extra round trip is inherent to its API."
+      },
+      "first_npx_ms": 3439,
+      "first_npx_ms_method": "wall clock of the very first `npx -y <pkg>@latest --help` on a cold npm cache (download + install + start); later runs reuse the npx cache",
+      "idle_rss_mb": {
+        "total_mb": 1414,
+        "chrome_tree_mb": 1290.1,
+        "node_npx_mb": 123.9,
+        "chrome_process_count": 8,
+        "total_process_count": 10,
+        "chrome_processes": [
+          {
+            "pid": 27560,
+            "rss_mb": 581.3
+          },
+          {
+            "pid": 29419,
+            "rss_mb": 134.8
+          },
+          {
+            "pid": 27575,
+            "rss_mb": 125.2
+          },
+          {
+            "pid": 27572,
+            "rss_mb": 121.7
+          },
+          {
+            "pid": 27566,
+            "rss_mb": 101.5
+          },
+          {
+            "pid": 27567,
+            "rss_mb": 82
+          },
+          {
+            "pid": 27574,
+            "rss_mb": 78.8
+          },
+          {
+            "pid": 27568,
+            "rss_mb": 65.4
+          }
+        ],
+        "method": "sum of `ps -Ao rss=` (KB) over every descendant of the spawned npx pid, 180 s after navigate returned; chrome_tree_mb restricts that sum to the subtree rooted at the launched Google Chrome binary. macOS RSS counts private + shared mapped pages per process, so summing over Chrome helpers (each mapping the same Chrome Framework) overstates true memory use; the per-process list is included so the double counting is visible. No dedup is applied because the task asks for the RSS sum."
+      },
+      "restart_ms": 5133,
+      "tab_switch_ms": {
+        "total_ms": 3416,
+        "open_second_page_ms": 3392,
+        "switch_back_and_read_ms": 24,
+        "second_page_url": "https://en.wikipedia.org/wiki/Main_Page",
+        "second_page_loaded": true,
+        "read_ok": true,
+        "control_open_second_page_same_tool_example_com_ms": 65
+      },
+      "idle_cpu_pct": {
+        "avg_pct_all_windows": 38.07,
+        "steady_state_avg_pct_after_60s": 40.38,
+        "peak_window_pct": 62.87,
+        "windows": [
+          {
+            "window": "0-30s after navigate",
+            "avg_cpu_pct_of_one_core": 6.37,
+            "pids": 9,
+            "top": [
+              {
+                "pid": 33217,
+                "sec": 1.77
+              },
+              {
+                "pid": 33223,
+                "sec": 0.04
+              },
+              {
+                "pid": 33229,
+                "sec": 0.04
+              }
+            ]
+          },
+          {
+            "window": "30-60s after navigate",
+            "avg_cpu_pct_of_one_core": 62.87,
+            "pids": 9,
+            "top": [
+              {
+                "pid": 33217,
+                "sec": 18.85
+              },
+              {
+                "pid": 33224,
+                "sec": 0.01
+              }
+            ]
+          },
+          {
+            "window": "60-90s after navigate",
+            "avg_cpu_pct_of_one_core": 7.13,
+            "pids": 9,
+            "top": [
+              {
+                "pid": 33217,
+                "sec": 2.09
+              },
+              {
+                "pid": 33216,
+                "sec": 0.01
+              },
+              {
+                "pid": 33223,
+                "sec": 0.01
+              }
+            ]
+          },
+          {
+            "window": "90-120s after navigate",
+            "avg_cpu_pct_of_one_core": 52.6,
+            "pids": 9,
+            "top": [
+              {
+                "pid": 33217,
+                "sec": 15.67
+              },
+              {
+                "pid": 33199,
+                "sec": 0.06
+              },
+              {
+                "pid": 33216,
+                "sec": 0.05
+              }
+            ]
+          },
+          {
+            "window": "120-150s after navigate",
+            "avg_cpu_pct_of_one_core": 61.4,
+            "pids": 9,
+            "top": [
+              {
+                "pid": 33217,
+                "sec": 18.42
+              }
+            ]
+          }
+        ],
+        "cross_check_bench_run_avg_pct": 35.75,
+        "cross_check_top_instantaneous_pct": [
+          {
+            "window": "0-15s",
+            "delta_method_pct": 28.7,
+            "top_l2_pct": 0
+          },
+          {
+            "window": "15-30s",
+            "delta_method_pct": 59.6,
+            "top_l2_pct": 49.6
+          },
+          {
+            "window": "30-45s",
+            "delta_method_pct": 26.5,
+            "top_l2_pct": 45.1
+          },
+          {
+            "window": "45-60s",
+            "delta_method_pct": 0.2,
+            "top_l2_pct": 0
+          },
+          {
+            "window": "60-75s",
+            "delta_method_pct": 64,
+            "top_l2_pct": 61.4
+          },
+          {
+            "window": "75-90s",
+            "delta_method_pct": 50.6,
+            "top_l2_pct": 48.3
+          },
+          {
+            "window": "90-105s",
+            "delta_method_pct": 29.7,
+            "top_l2_pct": 0
+          },
+          {
+            "window": "105-120s",
+            "delta_method_pct": 86.7,
+            "top_l2_pct": 53.4
+          }
+        ],
+        "method_controls": {
+          "sleep_process_cpu_seconds": 0,
+          "note": "The same ps-time delta applied to a plain `sleep 8` yields 0.00 CPU s, and top -l 2 (instantaneous per-process %CPU) on the Chrome main process tracks the delta method within sampling noise, so the numbers are CPU actually burned by the tree and not an accounting artifact."
+        },
+        "error": null,
+        "method": "Instantaneous CPU of the benchmark process tree, not the ps %cpu column. Every 30 s the cumulative CPU seconds of all tree pids are read from `ps -Ao pid=,time=`, and the delta divided by the 30 s wall window gives the average fraction of one core used by the whole tree (npx + node + all Chrome processes). Each window starts where the previous ended, from navigate +0 s; the early windows include Chrome post-load work and the ones after 60 s are the settled state. The ps %cpu column is a lifetime average and inflates for short-lived helpers, so it is only kept for reference."
+      },
+      "auto_release": {
+        "has_mechanism": true,
+        "parameter": "--idle-timeout <ms> | env PLAYWRIGHT_MCP_IDLE_TIMEOUT | config browser.idle",
+        "default_behavior": "one hour for headless browsers it launched, no timeout for headed or attached ones, 0 disables; the next tool call relaunches the browser",
+        "evidence": [
+          "https://github.com/microsoft/playwright-mcp/blob/main/README.md (README.md:431 in @playwright/mcp@0.0.84): \"--idle-timeout <timeout> | close the browser after this many milliseconds without a completed tool call, the next tool call relaunches it.\"",
+          "config.d.ts:240 in @playwright/mcp@0.0.84: \"idle?: number;\" with the comment \"Close the browser after this many milliseconds without a tool call, and relaunch it on the next one.\""
+        ],
+        "empirical": {
+          "flag_used": "--idle-timeout=6000",
+          "browser_auto_closed": true,
+          "details": "navigate, then 14 s without any tool call: chrome roots alive = 0, MCP process alive = true"
+        }
+      },
+      "notes": [
+        "cold_start run1 2887ms",
+        "cpu interval 1: 65.11% (ps %cpu sum for reference 63.5%) pids=9",
+        "cpu interval 2: 62.38% (ps %cpu sum for reference 63.7%) pids=9",
+        "cpu interval 3: 57.41% (ps %cpu sum for reference 13.1%) pids=9",
+        "cpu interval 4: 0.4% (ps %cpu sum for reference 0%) pids=9",
+        "cpu interval 5: 0.2% (ps %cpu sum for reference 0%) pids=9",
+        "cpu interval 6: 29.02% (ps %cpu sum for reference 64.3%) pids=9",
+        "idle rss total=1414MB chrome=1290.1MB node=123.9MB procs=10",
+        "tab_switch total 3416ms (open2 3392, back+read 24)",
+        "control second tab to example.com 65ms",
+        "kill tree pids 11, chrome roots 1, survivors after kill 1",
+        "restart_ms 5133ms (kill -> navigate return), cold run2 2755ms",
+        "cold_start run3 2464ms"
+      ],
+      "error": null
+    },
+    "chrome_devtools_mcp": {
+      "package": "chrome-devtools-mcp",
+      "package_version": "1.12.0",
+      "launch_command": "npx -y chrome-devtools-mcp@latest --headless --chromeArg=--use-mock-keychain",
+      "mcp_server_info": {
+        "name": "chrome_devtools",
+        "title": "Chrome DevTools MCP server",
+        "version": "1.12.0"
+      },
+      "cold_start_ms": {
+        "runs_ms": [
+          1596,
+          2185,
+          2337
+        ],
+        "min": 1596,
+        "median": 2185,
+        "max": 2337,
+        "definition": "wall clock from spawn(npx) to the navigate tool call returning the page URL, npx package cache warm (already downloaded). For chrome-devtools-mcp this includes the mandatory list_pages call that the tool schema requires to obtain a pageId; that extra round trip is inherent to its API."
+      },
+      "first_npx_ms": 17891,
+      "first_npx_ms_method": "wall clock of the very first `npx -y <pkg>@latest --help` on a cold npm cache (download + install + start); later runs reuse the npx cache",
+      "idle_rss_mb": {
+        "total_mb": 1279.8,
+        "chrome_tree_mb": 1108.8,
+        "node_npx_mb": 171,
+        "chrome_process_count": 7,
+        "total_process_count": 10,
+        "chrome_processes": [
+          {
+            "pid": 29867,
+            "rss_mb": 512.5
+          },
+          {
+            "pid": 30891,
+            "rss_mb": 132.5
+          },
+          {
+            "pid": 29877,
+            "rss_mb": 128
+          },
+          {
+            "pid": 29871,
+            "rss_mb": 102
+          },
+          {
+            "pid": 29872,
+            "rss_mb": 83.1
+          },
+          {
+            "pid": 29876,
+            "rss_mb": 79.9
+          },
+          {
+            "pid": 29873,
+            "rss_mb": 64.2
+          }
+        ],
+        "method": "sum of `ps -Ao rss=` (KB) over every descendant of the spawned npx pid, 180 s after navigate returned; chrome_tree_mb restricts that sum to the subtree rooted at the launched Google Chrome binary. macOS RSS counts private + shared mapped pages per process, so summing over Chrome helpers (each mapping the same Chrome Framework) overstates true memory use; the per-process list is included so the double counting is visible. No dedup is applied because the task asks for the RSS sum."
+      },
+      "restart_ms": 4585,
+      "tab_switch_ms": {
+        "total_ms": 2918,
+        "open_second_page_ms": 2903,
+        "switch_back_and_read_ms": 15,
+        "second_page_url": "https://en.wikipedia.org/wiki/Main_Page",
+        "second_page_loaded": true,
+        "read_ok": true,
+        "control_open_second_page_same_tool_example_com_ms": 151
+      },
+      "idle_cpu_pct": {
+        "avg_pct_all_windows": 36.29,
+        "steady_state_avg_pct_after_60s": 38.87,
+        "peak_window_pct": 60.27,
+        "windows": [
+          {
+            "window": "0-30s after navigate",
+            "avg_cpu_pct_of_one_core": 4.57,
+            "pids": 11,
+            "top": [
+              {
+                "pid": 34503,
+                "sec": 1.26
+              },
+              {
+                "pid": 34510,
+                "sec": 0.03
+              },
+              {
+                "pid": 34509,
+                "sec": 0.02
+              }
+            ]
+          },
+          {
+            "window": "30-60s after navigate",
+            "avg_cpu_pct_of_one_core": 60.27,
+            "pids": 10,
+            "top": [
+              {
+                "pid": 34503,
+                "sec": 18.07
+              },
+              {
+                "pid": 34510,
+                "sec": 0.01
+              }
+            ]
+          },
+          {
+            "window": "60-90s after navigate",
+            "avg_cpu_pct_of_one_core": 3.77,
+            "pids": 9,
+            "top": [
+              {
+                "pid": 34503,
+                "sec": 1.1
+              },
+              {
+                "pid": 34509,
+                "sec": 0.01
+              },
+              {
+                "pid": 34510,
+                "sec": 0.01
+              }
+            ]
+          },
+          {
+            "window": "90-120s after navigate",
+            "avg_cpu_pct_of_one_core": 56.87,
+            "pids": 9,
+            "top": [
+              {
+                "pid": 34503,
+                "sec": 16.93
+              },
+              {
+                "pid": 34466,
+                "sec": 0.06
+              },
+              {
+                "pid": 34500,
+                "sec": 0.06
+              }
+            ]
+          },
+          {
+            "window": "120-150s after navigate",
+            "avg_cpu_pct_of_one_core": 55.97,
+            "pids": 9,
+            "top": [
+              {
+                "pid": 34503,
+                "sec": 16.78
+              },
+              {
+                "pid": 34512,
+                "sec": 0.01
+              }
+            ]
+          }
+        ],
+        "cross_check_bench_run_avg_pct": 33.55,
+        "cross_check_top_instantaneous_pct": [
+          {
+            "window": "0-15s",
+            "delta_method_pct": 28.7,
+            "top_l2_pct": 0
+          },
+          {
+            "window": "15-30s",
+            "delta_method_pct": 59.6,
+            "top_l2_pct": 49.6
+          },
+          {
+            "window": "30-45s",
+            "delta_method_pct": 26.5,
+            "top_l2_pct": 45.1
+          },
+          {
+            "window": "45-60s",
+            "delta_method_pct": 0.2,
+            "top_l2_pct": 0
+          },
+          {
+            "window": "60-75s",
+            "delta_method_pct": 64,
+            "top_l2_pct": 61.4
+          },
+          {
+            "window": "75-90s",
+            "delta_method_pct": 50.6,
+            "top_l2_pct": 48.3
+          },
+          {
+            "window": "90-105s",
+            "delta_method_pct": 29.7,
+            "top_l2_pct": 0
+          },
+          {
+            "window": "105-120s",
+            "delta_method_pct": 86.7,
+            "top_l2_pct": 53.4
+          }
+        ],
+        "method_controls": {
+          "sleep_process_cpu_seconds": 0,
+          "note": "The same ps-time delta applied to a plain `sleep 8` yields 0.00 CPU s, and top -l 2 (instantaneous per-process %CPU) on the Chrome main process tracks the delta method within sampling noise, so the numbers are CPU actually burned by the tree and not an accounting artifact."
+        },
+        "error": null,
+        "method": "Instantaneous CPU of the benchmark process tree, not the ps %cpu column. Every 30 s the cumulative CPU seconds of all tree pids are read from `ps -Ao pid=,time=`, and the delta divided by the 30 s wall window gives the average fraction of one core used by the whole tree (npx + node + all Chrome processes). Each window starts where the previous ended, from navigate +0 s; the early windows include Chrome post-load work and the ones after 60 s are the settled state. The ps %cpu column is a lifetime average and inflates for short-lived helpers, so it is only kept for reference."
+      },
+      "auto_release": {
+        "has_mechanism": false,
+        "parameter": null,
+        "default_behavior": "browser starts on the first tool call that needs it and stays alive until the MCP client disconnects the CDP session or the server process exits; no idle timer",
+        "evidence": [
+          "https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/README.md (README.md:101 in chrome-devtools-mcp@1.12.0): \"The MCP server will start the browser automatically once the MCP client uses a tool that requires a running browser instance.\"",
+          "`chrome-devtools-mcp --help` (v1.12.0) lists no idle/close/timeout flag; the only flag mentioning cleanup is --isolated (\"temporary user-data-dir that is automatically cleaned up after the browser is closed\").",
+          "build/src/BrowserManager.js:476 in chrome-devtools-mcp@1.12.0 defines #closeBrowser(), reached from the shutdown path (line 184) and from the disconnected handler (#evictIfCurrent, line 442); nothing schedules it on idleness."
+        ],
+        "empirical": {
+          "flag_used": null,
+          "browser_auto_closed": null,
+          "details": "no flag exists to shorten a timeout, so this side was established from --help and source only, not by waiting an hour."
+        }
+      },
+      "notes": [
+        "cold_start run1 1596ms",
+        "cpu interval 1: 63.49% (ps %cpu sum for reference 62.8%) pids=10",
+        "cpu interval 2: 59.24% (ps %cpu sum for reference 63.4%) pids=10",
+        "cpu interval 3: 56.53% (ps %cpu sum for reference 50%) pids=10",
+        "cpu interval 4: 21.45% (ps %cpu sum for reference 0.4%) pids=10",
+        "cpu interval 5: 0.3% (ps %cpu sum for reference 0%) pids=9",
+        "cpu interval 6: 0.3% (ps %cpu sum for reference 0%) pids=9",
+        "idle rss total=1279.8MB chrome=1108.8MB node=171MB procs=10",
+        "tab_switch total 2918ms (open2 2903, back+read 15)",
+        "control second tab to example.com 151ms",
+        "kill tree pids 12, chrome roots 1, survivors after kill 1",
+        "restart_ms 4585ms (kill -> navigate return), cold run2 2185ms",
+        "cold_start run3 2337ms"
+      ],
+      "error": null
+    }
+  },
+  "method": {
+    "overview": "macOS arm64, one competitor at a time, no other Chrome running. Each competitor was driven over MCP stdio (newline-delimited JSON-RPC: initialize with protocolVersion 2024-11-05, notifications/initialized, then tools/call) by a ~200-line Node client with no dependencies (/tmp/compbench/mcp_client.mjs). Both were launched exactly the way a user would launch them with npx, headless, plus --use-mock-keychain so macOS does not open a keychain dialog. The navigated page was always https://example.com.",
+    "steps": {
+      "first_npx_ms": "Before any measurement, `time npx -y <pkg>@latest --help` was run once for each package against a cold npm cache; that number is first_npx_ms (download + install + start). All later runs reused the npx cache, so cold_start_ms excludes the download.",
+      "package_version": "The version npx resolves is what `npm view <pkg> version` reports at measurement time: @playwright/mcp 0.0.84, chrome-devtools-mcp 1.12.0. The MCP serverInfo is recorded alongside it.",
+      "cold_start_ms": "Timer starts immediately before spawn(npx) and stops when the navigate tool call returns. Three repetitions per competitor, each from a freshly spawned server; min/median/max over the three. For chrome-devtools-mcp the tool schema requires a pageId, so the flow includes one list_pages round trip before navigate_page.",
+      "idle_rss_mb": "After navigate returned the process tree was left alone for 180 s, then every descendant of the spawned npx pid was read with `ps -Ao pid=,ppid=,rss=` and RSS summed (total_mb). chrome_tree_mb is the same sum restricted to the subtree rooted at the launched Google Chrome binary; node_npx_mb is the remainder. macOS RSS counts shared mapped pages in every process, so a Chrome helper set that maps the same framework inflates the sum; the per-process list is kept in the report so that double counting stays visible, and no dedup is applied because the requested metric is the RSS sum.",
+      "idle_cpu_pct": "Cumulative CPU seconds (`ps -Ao time=`) of every tree pid were sampled every 30 s and differenced, giving the fraction of one core burned by npx+node+Chrome in each window, from the moment navigate returned. The method was validated twice: a plain `sleep 8` shows 0.00 CPU s under the same delta, and `top -l 2` (instantaneous %CPU) on the Chrome main process matches the delta values window by window. The ps %cpu column was not used because it is a lifetime average. The measured CPU is not near zero even with no tool call issued: the Chrome main process alone swings between ~0 and ~87 % of one core, which is Chrome background work, not benchmark overhead.",
+      "tab_switch_ms": "With example.com already open, a second page was opened at https://en.wikipedia.org/wiki/Main_Page (Playwright MCP: browser_tabs new + browser_navigate; chrome-devtools-mcp: new_page), then the browser switched back to the first page and read it (browser_tabs select index 0 + browser_snapshot / list_pages + select_page + take_snapshot). total_ms covers the whole cycle. Because wikipedia load time dominates, the same \"open a second page\" call was repeated against example.com as a control, which isolates tool overhead from page load.",
+      "restart_ms": "The whole spawned tree was SIGKILLed deepest-first, the death was verified with a fresh ps snapshot (any survivor re-killed), then a new npx process was spawned, initialized and navigated to example.com; restart_ms is kill-start to navigate-return.",
+      "auto_release": "Documented behaviour was read from the shipped README and source of the exact installed versions, with line numbers. For Playwright MCP the idle timeout was additionally verified empirically: server started with --idle-timeout=6000, navigate, then 14 s without any tool call, then a fresh process-tree snapshot to see whether Chrome was gone.",
+      "process_hygiene": "Every kill was scoped to the descendants of the npx pid this benchmark spawned (tree walk from ps ppid, deepest first) plus the Chrome roots recorded in that tree; no name-based kill was used against system Chrome, and after each kill a fresh snapshot verified that nothing was left."
+    },
+    "failure_points": [
+      "chrome-devtools-mcp navigate_page requires a pageId, and the id is 1-based: pageId 0 returns \"Error: No page found\". Its list_pages result is human-formatted Markdown (\"1: Example Domain (https://example.com/) [selected]\"), not JSON, so the id has to be parsed from the text. Two early probe runs failed on these two points before the driver was fixed.",
+      "An early smoke test cleaned up by SIGKILLing every process whose command line matched \"Contents/MacOS/Google Chrome\"; that killed the user's own Chrome main process (pid 97712) instead of only the benchmark tree. It was replaced by the tree-scoped kill now used everywhere. Consequence for this report: no user Chrome was running for any of the measurements below, which removes browser noise from CPU and memory, and the machine was otherwise idle.",
+      "A first version of the idle CPU metric summed the ps %cpu column; with freshly forked Chrome helpers that column reports a lifetime average and produced implausible values (up to 98.7 % in an early run). It was replaced by the CPU-seconds-delta method.",
+      "wikipedia.org load time varied between runs (3.4 s and 2.9 s in the reported run, 10 s in an earlier run on the same machine and network), which is why tab_switch_ms is reported together with its example.com control and not as tool overhead.",
+      "No measurement required a system-level change; nothing outside /tmp/compbench was written and no project repository was touched."
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-inner-browser-use",
-  "version": "0.46.0",
+  "version": "0.47.0",
   "description": "An agent-owned Chromium sidecar mirrored into the DeepSeek Harness right column: the agent drives it, the person watches and can take the mouse, and logins survive restarts.",
   "type": "module",
   "main": "index.js",
@@ -35,6 +35,7 @@
     "scripts/check-sites.mjs",
     "scripts/soak.mjs",
     "scripts/check-rest.mjs",
+    "scripts/bench-resource.mjs",
     "runtime/",
     "docs/",
     "README.md",
@@ -75,7 +76,8 @@
     "look": "node scripts/check-look.mjs",
     "sites": "node scripts/check-sites.mjs",
     "soak": "node scripts/soak.mjs",
-    "rest": "node scripts/check-rest.mjs"
+    "rest": "node scripts/check-rest.mjs",
+    "bench": "node scripts/bench-resource.mjs"
   },
   "license": "MIT",
   "author": {

package/scripts/bench-resource.mjs

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+/**
+ * What this browser costs, in the same terms the neighbours are measured in.
+ *
+ *   node scripts/bench-resource.mjs [--json out.json]
+ *
+ * Cold start, action round trip, idle memory and CPU with a page open, the
+ * reversible freeze, the rest, and the wake. One process tree, one page, the
+ * same protocol `docs/RESOURCES.md` uses for Playwright MCP and Chrome DevTools
+ * MCP — so the numbers can sit in one table.
+ */
+import { createServer } from 'node:http'
+import { execFileSync } from 'node:child_process'
+import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+process.env.DSH_INNER_BROWSER_STATE_DIR = mkdtempSync(join(tmpdir(), 'dsh-bench-'))
+const sink = (() => {
+  const at = process.argv.indexOf('--json')
+  return at === -1 ? null : process.argv[at + 1]
+})()
+
+const server = createServer((request, response) => {
+  response.writeHead(200, { 'content-type': 'text/html; charset=utf-8' })
+  response.end('<!doctype html><meta charset="utf-8"><title>bench</title><h1>bench</h1>' +
+    `<p>${'the page has to cost what a page costs. '.repeat(40)}</p>` +
+    '<ul>' + Array.from({ length: 60 }, (_, i) => `<li><a href="/row-${i}">row ${i}</a></li>`).join('') + '</ul>')
+})
+await new Promise((done) => server.listen(0, '127.0.0.1', done))
+const url = `http://127.0.0.1:${server.address().port}/page`
+
+const { Sidecar } = await import('../sidecar.js')
+const { sidecarTools, sessionScope, workScope } = await import('../tools.js')
+
+const wait = (ms) => new Promise((settle) => setTimeout(settle, ms))
+const sidecar = new Sidecar({ profile: 'bench-resource', headless: true, restFloor: 1200, restCeiling: 1600, budgetMb: 4000 })
+const tools = sidecarTools(sidecar, { byChat: new Map() }, {})
+const tool = (name) => tools.find((one) => one.name === name)
+const cwd = mkdtempSync(join(tmpdir(), 'dsh-bench-cwd-'))
+const chat = 'session-bench-resource'
+const run = (name, args) => sessionScope.run(chat, () => workScope.run(cwd, () => tool(name).execute(args, { agent: { id: chat } })))
+const text = (said) => String(said?.text ?? '')
+
+/* ps once per sample: pid, parent, cpu, rss. macOS sums shared pages per
+   process, so the total overstates real memory; the neighbours are measured the
+   same way, which is the only way the numbers compare. */
+function tree(root) {
+  const rows = execFileSync('ps', ['-Ao', 'pid=,ppid=,%cpu=,rss='], { encoding: 'utf8' })
+    .trim().split('\n').map((line) => line.trim().split(/\s+/)).map(([pid, ppid, cpu, rss]) => ({ pid: Number(pid), ppid: Number(ppid), cpu: Number(cpu), rss: Number(rss) }))
+  const byParent = new Map()
+  for (const row of rows) {
+    if (!byParent.has(row.ppid)) byParent.set(row.ppid, [])
+    byParent.get(row.ppid).push(row)
+  }
+  const out = []
+  const walk = (pid) => {
+    for (const child of byParent.get(pid) ?? []) {
+      out.push(child)
+      walk(child.pid)
+    }
+  }
+  walk(root)
+  return out
+}
+function weigh() {
+  const root = sidecar.child?.pid
+  if (!root) return { mb: 0, cpu: 0, procs: 0 }
+  const rows = tree(root)
+  return {
+    mb: Math.round(rows.reduce((sum, row) => sum + row.rss, 0) / 1024),
+    cpu: Number(rows.reduce((sum, row) => sum + row.cpu, 0).toFixed(1)),
+    procs: rows.length + 1,
+  }
+}
+async function cpuOver(ms, every = 5000) {
+  const samples = []
+  const until = Date.now() + ms
+  while (Date.now() < until) {
+    samples.push(weigh().cpu)
+    await wait(Math.min(every, Math.max(0, until - Date.now())))
+  }
+  return {
+    samples_pct: samples,
+    avg_pct: Number((samples.reduce((a, b) => a + b, 0) / Math.max(1, samples.length)).toFixed(2)),
+  }
+}
+
+const report = { generated_at: new Date().toISOString(), host: { arch: process.arch, platform: process.platform }, version: JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version }
+let failed = 0
+const check = (ok, what) => {
+  console.log(`${ok ? 'ok  ' : 'FAIL'} ${what}`)
+  if (!ok) failed += 1
+}
+
+try {
+  /* Keep the rest out of the way while the page is measured. */
+  const coldAt = Date.now()
+  await run('browser_open', { url })
+  const first = text(await run('browser_view', {}))
+  report.cold_start_ms = Date.now() - coldAt
+  check(first.includes('bench'), `cold start ${String(report.cold_start_ms)} ms`)
+  check(report.cold_start_ms < 6000, 'cold start under six seconds')
+
+  const readAt = Date.now()
+  const read = text(await run('browser_read', {}))
+  report.read_ms = Date.now() - readAt
+  report.read_chars = read.length
+  check(report.read_ms < 4000 && read.length > 200, `a read is ${String(report.read_ms)} ms and ${String(report.read_chars)} chars`)
+
+  const evalAt = Date.now()
+  for (let i = 0; i < 5; i += 1) await run('browser_eval', { code: 'document.title' })
+  report.action_rtt_ms = Math.round((Date.now() - evalAt) / 5)
+  check(report.action_rtt_ms < 500, `an action round trip is ${String(report.action_rtt_ms)} ms`)
+
+  const up = weigh()
+  report.open_rss_mb = up.mb
+  report.open_procs = up.procs
+  check(up.mb > 0, `a page open costs ${String(up.mb)} MB in ${String(up.procs)} processes`)
+
+  /* The first seconds after a load are the page finishing; the number that
+     matters is what it costs once it has finished. */
+  sidecar.touch(600_000)
+  await wait(5000)
+  report.idle_cpu = await cpuOver(30_000)
+  sidecar.touch(600_000)
+  await wait(2000)
+  const idle = weigh()
+  report.idle_rss_mb = idle.mb
+  check(true, `idle 30 s: ${String(idle.mb)} MB, ${String(report.idle_cpu.avg_pct)} % cpu`)
+
+  /* The reversible park: the page keeps its DOM, the process keeps its share. */
+  const frozenAt = Date.now()
+  await sidecar.pageFor(chat)?.freeze()
+  await wait(3000)
+  const frozen = weigh()
+  report.freeze_ms = Date.now() - frozenAt
+  report.frozen_rss_mb = frozen.mb
+  const frozenCpu = await cpuOver(6000)
+  report.frozen_cpu_pct = frozenCpu.avg_pct
+  check(report.frozen_rss_mb <= idle.mb + 8, `frozen costs ${String(report.frozen_rss_mb)} MB, was ${String(idle.mb)} MB`)
+
+  const thawAt = Date.now()
+  await sidecar.pageFor(chat)?.thaw()
+  const quick = text(await run('browser_view', {}))
+  report.thaw_ms = Date.now() - thawAt
+  check(quick.includes('bench') || quick.includes('nothing changed'), `thaw took ${String(report.thaw_ms)} ms`)
+
+  /* The full release and the wake that costs a cold launch. */
+  sidecar.touch(600)
+  for (let i = 0; i < 60; i += 1) {
+    await wait(200)
+    if ((await sidecar.state()).alive !== true) break
+  }
+  const asleep = await sidecar.state()
+  report.rested = asleep.alive !== true
+  report.asleep_mb = asleep.memory
+  check(report.rested && asleep.memory === 0, `rest releases everything (${String(asleep.memory)} bytes)`)
+
+  const wakeAt = Date.now()
+  const back = text(await run('browser_view', {}))
+  report.wake_ms = Date.now() - wakeAt
+  check(sidecar.pageFor(chat)?.url === url, `wake came back to ${String(sidecar.pageFor(chat)?.url)} in ${String(report.wake_ms)} ms`)
+  check(back.length > 0, 'the page still reads after the wake')
+} finally {
+  server.close()
+  await sidecar.shutdown().catch(() => {})
+}
+
+console.log('\n' + JSON.stringify(report, null, 2))
+if (sink !== null) writeFileSync(sink, JSON.stringify(report, null, 2) + '\n')
+console.log(failed === 0 ? '\nresource numbers hold.' : `\n${String(failed)} bench checks failed.`)
+process.exitCode = failed === 0 ? 0 : 1

package/sidecar.js

@@ -1504,9 +1504,26 @@ export class SidecarPage {
    * a launch and a sign-in. Chrome's own docs define the two states.
    * @returns {Promise<void>} done, even on a page that cannot be frozen.
    */
+  /**
+   * What a parked page gives back: the heap it grew while it was being read,
+   * and the decoded images and back/forward caches the renderer keeps for a
+   * page a person may look at again. Frozen pages cannot run the collector, so
+   * this happens before the freeze — the DOM, the scroll position and the
+   * cookies are untouched, which is the whole point of parking instead of
+   * closing.
+   * @returns {Promise<void>} done, even on a renderer that refuses.
+   */
+  async shed() {
+    await this.cdp.send('Runtime.evaluate', {
+      expression: 'globalThis.gc?.()', silent: true, returnByValue: true,
+    }).catch(() => {})
+    await this.cdp.send('Memory.simulatePressureNotification', { level: 'critical' }).catch(() => {})
+  }
+
   async freeze() {
     if (this.frozen === true) return
     try {
+      await this.shed()
       await this.cdp.send('Page.setWebLifecycleState', { state: 'frozen' })
       this.frozen = true
       this.casting = false
@@ -2381,6 +2398,10 @@ export class Sidecar {
     this.expired?.delete(id)
     const had = this.pageFor(id)
     if (had !== null) {
+      /* A parked page is still the chat's page: waking it costs a protocol call,
+         and a tool that read without waking it would see a page that never runs
+         its scripts again. */
+      await had.thaw?.()
       if (url !== undefined && url !== '') await had.navigate(url)
       return had
     }
@@ -2389,6 +2410,7 @@ export class Sidecar {
     const underway = this.opening?.get(id)
     if (underway !== undefined) {
       const page = await underway
+      await page.thaw?.()
       const want = String(url ?? '')
       if (want !== '' && String(page.url ?? '') !== want) await page.navigate(want)
       return page
@@ -2541,6 +2563,10 @@ export class Sidecar {
     this.expired?.delete(String(id))
     const had = this.pageFor(id)
     if (had !== null) {
+      /* A parked page is still the chat's page: waking it costs a protocol call,
+         and a tool that read without waking it would see a page that never runs
+         its scripts again. */
+      await had.thaw?.()
       if (url !== undefined && url !== '') await had.navigate(url)
       return had
     }
@@ -2865,7 +2891,7 @@ export class Sidecar {
       '--no-default-browser-check',
       '--use-mock-keychain',
       '--disable-blink-features=AutomationControlled',
-      '--disable-features=Translate,MediaRouter,OptimizationHints',
+      '--disable-features=Translate,MediaRouter,OptimizationHints,InterestFeedContentSuggestions,CalculateNativeWinOcclusion',
       '--disable-sync',
       /* The driver clicks for a person, and a page that opens a tab on a click
          is doing what the page means to do. Blocking it would strand the
@@ -2882,6 +2908,24 @@ export class Sidecar {
       '--disable-renderer-backgrounding',
       '--disable-ipc-flooding-protection',
       '--metrics-recording-only',
+      /* Nothing here talks to Google while the person is not reading: the
+         update, the crash reporter and the network pings all cost a process,
+         a socket and a wake-up on a page that is only being looked at. */
+      '--disable-background-networking',
+      '--disable-component-update',
+      '--disable-domain-reliability',
+      '--disable-client-side-phishing-detection',
+      '--disable-breakpad',
+      '--disable-crash-reporter',
+      '--no-pings',
+      '--disable-extensions',
+      '--disable-default-apps',
+      /* A page nobody looks at can hand its heap back when it is parked; the
+         renderer needs the flag before it will collect on request. */
+      '--js-flags=--expose-gc',
+      /* Six tabs never need six renderers: the cap keeps the resident cost of a
+         browsing session flat, while four still keeps unrelated sites apart. */
+      '--renderer-process-limit=4',
       '--no-service-autorun',
       '--password-store=basic',
       '--lang=zh-CN',
@@ -2895,6 +2939,10 @@ export class Sidecar {
       '--window-position=-3000,-3000',
       'about:blank',
     ]
+    /* An escape hatch for measuring one flag against another without editing
+     * the source: space-separated extra switches, never a replacement. */
+    const extra = String(process.env.DSH_INNER_BROWSER_CHROME_FLAGS ?? '').trim()
+    if (extra !== '') args.push(...extra.split(/\s+/))
     if (flash !== null) {
       /* Electron takes these switches through its own command line, not the
          argv it hands the app, so the runtime app reads them from here. */