oh-my-opencode 5.0.0-beta.62 → 5.0.0-beta.64

package/packages/omo-codex/plugin/skills/ultimate-browsing/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: ultimate-browsing
-description: "Reaches web pages a plain fetch cannot: renders JS, drives clicks and forms, captures screenshots, holds a login, and gets past WAF blocks through platform-native readers and stealth Chrome. Use for any page work beyond retrieving static text."
+description: "Renders, drives, and screenshots web pages: JS-rendered sources, clicks and forms, persistent logins, WAF-blocked hosts (platform-native readers, stealth Chrome), and the browsing lane of a research run, with screenshots as provenance. Not for plain search or unblocked static fetch."
 ---
 
 # Ultimate Browsing
 
 Web access for everything a plain fetch cannot finish: a page that renders in JS, a click or a form, a screenshot, a login that must persist across pages, or a host that blocks generic fetchers (WAF / 403 / Cloudflare). Start at the cheapest tier that can do the job and climb only when it cannot:
 
-**Tier 1 — insane-search** (headless extraction + WAF bypass) -> **Tier 1.5 — agent-reach** (platform-native APIs, esp. Chinese platforms) -> **Tier 2 — a real browser**: 2a a code-driven kernel browser, 2b Chrome stealth (CloakBrowser + agent-browser) when the page fights back.
+**Tier 1 — insane-search** (headless extraction + WAF bypass) -> **Tier 1.5 — agent-reach** (platform-native APIs, esp. Chinese platforms) -> **Tier 2 — a real browser**: 2a Bun.WebView, 2b a local-Chrome `playwright-core` script from js eval for Chrome semantics, stealth, trace, or auth.
 
 ## PHASE 0 — ROUTE FIRST (MANDATORY)
 
@@ -86,33 +86,26 @@ Routing table, per-platform auth (set `TWITTER_*` env vars, `gh auth login`, a t
 
 ### Tier 2a — kernel browser (default)
 
-Drive the page from the code cell you are already in, with no CLI process and no open CDP port. On a Bun >= 1.4 runtime that is `new Bun.WebView()` (`navigate`, `click`, `type`, `evaluate`, `screenshot`, raw `cdp`); elsewhere it is `playwright-core`/`puppeteer-core` against the local Chrome. Snapshots and screenshots come back in-process, so this is the cheapest way to answer "what does the page actually render".
+Use `new Bun.WebView()` from the js-eval kernel on Bun >= 1.4: macOS defaults to system WebKit; Linux/Windows need installed Chrome/Chromium/Edge. WebView is headless, WebKit has no CDP, and `type()` emits no keyboard events. For other kernels or when those differences matter, use 2b.
 
 ```js
-await using view = new Bun.WebView({ width: 1280, height: 800 })
-await view.navigate(url)
-const title = await view.evaluate("document.title")
-await view.screenshot({ path: "/tmp/page.png" })
+const view = new Bun.WebView({ width: 1280, height: 800 })
+try {
+  await view.navigate(url)
+  const title = await view.evaluate("document.title")
+  await Bun.write(pngPath, await view.screenshot())
+} finally {
+  view[Symbol.dispose]()
+}
 ```
 
-Climb to 2b when the site detects automation (Turnstile, FingerprintJS, "unusual traffic"), when the flow needs a persistent logged-in profile or injected cookies, or when the kernel browser cannot reach the page at all.
+Use 2b for real-Chrome semantics, stealth, trace, authenticated profiles, or a page the kernel browser cannot reach.
 
 ### Tier 2b — Chrome stealth (blocked or logged-in pages)
 
-CloakBrowser is a stealth Chromium with source-level fingerprint patches that passes Cloudflare Turnstile, FingerprintJS, BrowserScan, and 30+ detectors; agent-browser is the CDP automation CLI that drives it. Both are runtime-installed tools (not vendored here). Full setup, version pins, launch flow, cookie login, and cross-platform notes are in [references/chrome-stealth.md](references/chrome-stealth.md).
+WRITE a `playwright-core` script and run it from js eval against installed local Chrome: `chromium.launch({ channel: "chrome" })`, or `launchPersistentContext` on a task-owned profile. For authenticated state, CLONE the user's profile first (`rsync -a <profile>/ <tmp-clone>/`); NEVER launch against or clear cookies/cache/site data from the live profile. Codex: prefer `browser:control-in-app-browser` for ordinary page control.
 
-NEVER clear cookies, cache, or site data (`Network.clearBrowserCookies`, `Storage.clearCookies`, `chrome.browsingData.remove`, "clear browsing data") on the user's real/main browser profile — it wipes their logged-in state everywhere. If the task needs that profile's login state, clone the profile directory first (`rsync -a <profile>/ <tmp-clone>/`) and launch CloakBrowser / agent-browser with the clone as the user-data-dir; run any clearing on the clone only.
-
-```bash
-# 1. Launch CloakBrowser with CDP on :9242 (see chrome-stealth.md for install + venv).
-# 2. CloakBrowser launches tabless — open the first tab via CDP before any agent-browser command:
-curl -s -X PUT "http://127.0.0.1:9242/json/new?https://example.com"
-# 3. Drive it with agent-browser over CDP:
-agent-browser --cdp 9242 snapshot -i        # interactive elements (@eN refs)
-agent-browser --cdp 9242 click @e3
-agent-browser --cdp 9242 screenshot out.png
-agent-browser --cdp 9242 close
-```
+Keep the engine's Playwright templates for script-based extraction. Stealth is optional: the user installs `playwright-extra` + `puppeteer-extra-plugin-stealth` once in the engine directory and the script wraps the `playwright-core` browser type. Setup, persistent-context arguments, screenshots, and cleanup are in [references/chrome-stealth.md](references/chrome-stealth.md). A stealth flag is not proof of access: inspect the rendered result and report challenges that remain.
 
 ### Cookie login (cross-platform)
 
@@ -134,14 +127,11 @@ Cookie export files are written with owner-only `0600` permissions. Do not place
 |------|-------------|
 | [references/insane-search/README.md](references/insane-search/README.md) | Tier-1 engine harness (R1-R7, Phase 0 API index, no-site-name rule) + its `*.md` deep-dives |
 | [references/agent-reach/README.md](references/agent-reach/README.md) | Tier-1.5 routing table, platform auth, per-category `*.md` |
-| [references/chrome-stealth.md](references/chrome-stealth.md) | Tier-2 CloakBrowser + agent-browser install, CDP flow, version pins, cookie login |
+| [references/chrome-stealth.md](references/chrome-stealth.md) | Tier-2 playwright-core scripts, optional stealth setup, cloned profiles, cookie login |
 
 ## Environment variables
 
 ```bash
-CLOAK_CDP_PORT=9242              # CloakBrowser CDP port (default 9242)
-AGENT_BROWSER_USER_AGENT="..."   # override UA to hide HeadlessChrome
-AGENT_BROWSER_HEADED=1           # show the browser window
 # agent-reach auth: set the channel-specific env vars from each tool's docs only if you have access
 # insane-search needs no env vars — it auto-installs deps on first run
 ```
@@ -149,9 +139,7 @@ AGENT_BROWSER_HEADED=1           # show the browser window
 ## Anti-patterns
 
 - Do NOT launch Chrome stealth for plain text extraction — use Tier 1.
-- Do NOT pass an `--init-script` for the webdriver flag — CloakBrowser already patches it at source; the only required override is `--user-agent`.
-- Do NOT run agent-browser before creating the first tab via `curl -X PUT .../json/new` — CloakBrowser launches tabless.
-- Do NOT use vanilla Chrome when stealth is needed — always CloakBrowser.
-- Do NOT forget to `close` the session when done.
+- Use stealth plugins only in an explicitly installed script environment, not injected into WebView.
+- Close every WebView/browser context when done and remove only task-owned profile clones.
 - Do NOT inject cookies without reloading the page.
 - Do NOT hardcode site domains/selectors into `engine/**` or `waf_profiles.yaml` — runtime hints only (see the no-site-name rule in the insane-search reference).

package/packages/omo-codex/plugin/skills/ultimate-browsing/engine/AGENTS.md

@@ -65,7 +65,8 @@ is a regression, not an upgrade:
 - **De-personalization** — no personal absolute paths, no personal auth token literals,
   no personal browser choice; enforced by `depersonalization-gate.test.ts`.
 - **Skill-level layering** — the engine is Tier 1 under a router that also owns Tier 1.5
-  (agent-reach) and Tier 2 (CloakBrowser + agent-browser). Upstream has no such tiering.
+  (agent-reach) and Tier 2 (Bun.WebView / local-Chrome playwright-core scripts from js eval).
+  Upstream has no such tiering.
 
 ### WANT — upstream improvements worth porting forward
 

package/packages/omo-codex/plugin/skills/ultimate-browsing/engine/templates/package.json

@@ -2,9 +2,9 @@
   "name": "insane-search-templates",
   "version": "0.1.0",
   "private": true,
-  "description": "Local deps for Playwright real-Chrome templates. npm install && npx playwright install chrome",
+  "description": "Script-only dependencies for local Chrome templates driven from js eval; Chrome must already be installed.",
   "dependencies": {
-    "playwright": "^1.62.1",
+    "playwright-core": "^1.62.1",
     "playwright-extra": "^4.3.6",
     "puppeteer-extra-plugin-stealth": "^2.11.2"
   }

package/packages/omo-codex/plugin/skills/ultimate-browsing/engine/templates/playwright_mobile_chrome.js

@@ -76,11 +76,12 @@ async function main() {
   const playwrightExtra = requireOptionalModule('playwright-extra');
   const stealthPlugin = playwrightExtra ? requireOptionalModule('puppeteer-extra-plugin-stealth') : null;
   if (playwrightExtra && stealthPlugin) {
-    ({ chromium, devices } = playwrightExtra);
+    ({ devices } = require('playwright-core'));
+    chromium = playwrightExtra.addExtra(require('playwright-core').chromium);
     const stealth = stealthPlugin();
     chromium.use(stealth);
   } else {
-    ({ chromium, devices } = require('playwright'));
+    ({ chromium, devices } = require('playwright-core'));
   }
 
   const dev = devices[deviceName];
@@ -94,6 +95,8 @@ async function main() {
   try {
     ctx = await chromium.launchPersistentContext(profileDir, {
       channel: 'chrome',
+      args: ['--disable-blink-features=AutomationControlled'],
+      ignoreDefaultArgs: ['--enable-automation'],
       headless,
       ...dev,
     });

package/packages/omo-codex/plugin/skills/ultimate-browsing/engine/templates/playwright_real_chrome.js

@@ -10,9 +10,9 @@
  * NO-SITE-NAME RULE: this file must never branch on specific hostnames.
  * All site specifics come from the JSON input (url, waitSelector).
  *
- * Dependencies (install once on target machine):
- *   npm i -g playwright playwright-extra puppeteer-extra-plugin-stealth
- *   npx playwright install chrome    # system Chrome binary
+ * User setup: ../../references/chrome-stealth.md (engine-local dependencies).
+ * Chrome must already be installed; optional stealth plugins run only in this script.
+ * Execute this script from js eval; profileDir must be task-owned or a CLONED profile.
  */
 
 const fs = require('fs');
@@ -82,18 +82,20 @@ async function main() {
   const playwrightExtra = requireOptionalModule('playwright-extra');
   const stealthPlugin = playwrightExtra ? requireOptionalModule('puppeteer-extra-plugin-stealth') : null;
   if (playwrightExtra && stealthPlugin) {
-    ({ chromium } = playwrightExtra);
+    chromium = playwrightExtra.addExtra(require('playwright-core').chromium);
     const stealth = stealthPlugin();
     chromium.use(stealth);
   } else {
-    // Fallback to plain playwright (no stealth). Still uses channel:chrome.
-    ({ chromium } = require('playwright'));
+    // Core controls installed Chrome without downloading a managed browser.
+    ({ chromium } = require('playwright-core'));
   }
 
   let ctx;
   try {
     ctx = await chromium.launchPersistentContext(profileDir, {
       channel: 'chrome',          // real Chrome, not bundled Chromium
+      args: ['--disable-blink-features=AutomationControlled'],
+      ignoreDefaultArgs: ['--enable-automation'],
       headless,
       viewport,
     });

package/packages/omo-codex/plugin/skills/ultimate-browsing/engine/tests/test_playwright_stealth.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import tempfile
+import unittest
+from pathlib import Path
+
+from test_playwright_templates import (
+    TEMPLATE_NAMES,
+    TEMPLATES_DIR,
+    _install_fake_playwright,
+    _write_file,
+)
+
+
+class PlaywrightTemplateStealth(unittest.TestCase):
+    def test_extracts_html_and_closes_wrapped_chrome_when_stealth_is_installed(self) -> None:
+        for template_name in TEMPLATE_NAMES:
+            with self.subTest(template_name=template_name), tempfile.TemporaryDirectory() as tmp:
+                # Given: core has no plugin API; only addExtra supplies a registered wrapper.
+                root = Path(tmp)
+                modules = root / "node_modules"
+                profile = root / "profile"
+                receipt = root / "launch.json"
+                _install_fake_playwright(modules)
+                _write_file(modules / "puppeteer-extra-plugin-stealth/index.js", """
+                    module.exports = () => ({ name: 'stealth' });
+                """)
+                _write_file(modules / "playwright-extra/index.js", """
+                    const assert = require('node:assert/strict');
+                    const fs = require('node:fs');
+                    exports.addExtra = (core) => {
+                      assert.equal(core, require('playwright-core').chromium);
+                      assert.equal(Object.hasOwn(core, 'use'), false);
+                      const events = ['wrap'];
+                      let registered = false;
+                      return {
+                        use(plugin) {
+                          assert.equal(plugin.name, 'stealth');
+                          registered = true;
+                          events.push(plugin.name);
+                        },
+                        async launchPersistentContext(profileDir, options) {
+                          assert.equal(registered, true);
+                          events.push({ profileDir, channel: options.channel, viewport: options.viewport });
+                          const context = await core.launchPersistentContext(profileDir, options);
+                          return {
+                            ...context,
+                            async close() {
+                              await context.close();
+                              events.push('close');
+                              fs.writeFileSync(process.env.STEALTH_RECEIPT, JSON.stringify(events));
+                            },
+                          };
+                        },
+                      };
+                    };
+                """)
+                script = root / template_name
+                script.write_bytes((TEMPLATES_DIR / template_name).read_bytes())
+                env = {key: value for key, value in os.environ.items() if key != "NODE_PATH"}
+                env["STEALTH_RECEIPT"] = str(receipt)
+
+                # When: the actual bundled entry point consumes its normal stdin protocol.
+                result = subprocess.run(
+                    ["node", str(script)],
+                    input=json.dumps({"url": "https://example.com/", "profileDir": str(profile), "headless": True}),
+                    text=True, capture_output=True, timeout=5, env=env, check=False,
+                )
+
+                # Then: HTML arrives through the registered wrapper and the context is closed.
+                self.assertEqual(result.returncode, 0, result.stderr)
+                self.assertEqual(result.stdout, "<html><article>ok</article></html>")
+                self.assertEqual(result.stderr, "")
+                viewport = {"width": 390, "height": 844} if "mobile" in template_name else {"width": 1366, "height": 900}
+                self.assertEqual(json.loads(receipt.read_text(encoding="utf-8")), [
+                    "wrap", "stealth",
+                    {"profileDir": str(profile), "channel": "chrome", "viewport": viewport},
+                    "close",
+                ])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/packages/omo-codex/plugin/skills/ultimate-browsing/engine/tests/test_playwright_templates.py

@@ -21,7 +21,7 @@ def _write_file(path: Path, content: str) -> None:
 
 def _install_fake_playwright(node_modules: Path) -> None:
     _write_file(
-        node_modules / "playwright" / "index.js",
+        node_modules / "playwright-core" / "index.js",
         """
         const page = {
           async goto() {},
@@ -47,7 +47,6 @@ def _install_fake_playwright(node_modules: Path) -> None:
         };
 
         exports.chromium = {
-          use() {},
           async launchPersistentContext() { return context; },
         };
         exports.devices = {
@@ -78,9 +77,7 @@ def _install_working_playwright_extra(node_modules: Path) -> None:
     _write_file(
         node_modules / "playwright-extra" / "index.js",
         """
-        const playwright = require('playwright');
-        exports.chromium = playwright.chromium;
-        exports.devices = playwright.devices;
+        exports.addExtra = (browserType) => browserType;
         """,
     )
 
@@ -149,7 +146,7 @@ def _run_template(
 
 @unittest.skipUnless(shutil.which("node"), "node is required for Playwright template tests")
 class PlaywrightTemplateErrorHandling(unittest.TestCase):
-    def test_missing_playwright_extra_warns_and_falls_back_to_plain_playwright(self) -> None:
+    def test_missing_playwright_extra_warns_and_falls_back_to_playwright_core(self) -> None:
         for template_name in TEMPLATE_NAMES:
             with self.subTest(template_name=template_name):
                 result = _run_template(
@@ -166,7 +163,7 @@ class PlaywrightTemplateErrorHandling(unittest.TestCase):
                 self.assertIn("best-effort optional module playwright-extra failed:", result.stderr)
                 self.assertIn("Cannot find module 'playwright-extra'", result.stderr)
 
-    def test_missing_stealth_plugin_warns_and_falls_back_to_plain_playwright(self) -> None:
+    def test_missing_stealth_plugin_warns_and_falls_back_to_playwright_core(self) -> None:
         for template_name in TEMPLATE_NAMES:
             with self.subTest(template_name=template_name):
                 result = _run_template(

package/packages/omo-codex/plugin/skills/ultimate-browsing/references/chrome-stealth.md

@@ -1,127 +1,113 @@
-# Tier 2 — Chrome stealth (CloakBrowser + agent-browser)
+# Tier 2 — Chrome stealth through playwright-core scripts
 
-Real interaction (clicks, forms, screenshots, video, persistent login) for pages that defeat Tier 1/1.5. Two runtime tools, both installed on demand — neither is vendored in this skill:
-
-- **CloakBrowser** (`pip`) — stealth Chromium with source-level C++ fingerprint patches. The Python wrapper source is MIT; the downloaded Chromium binary is covered by CloakBrowser's separate binary license and is not redistributed by this package. Passes Cloudflare Turnstile, FingerprintJS, BrowserScan, and 30+ detectors. Pin **0.5.7**.
-- **agent-browser** (`npm`, Apache-2.0) — native CDP automation CLI that drives CloakBrowser. AX-tree snapshots, `@eN` refs, click/fill/type/scroll, screenshots, video, cookie/state/session management. Pin **0.34.0**.
-
-```
-CloakBrowser (stealth Chromium) <- CDP port 9242 -> agent-browser CLI
-  - 57 C++ fingerprint patches                  - AX-tree snapshots, @eN refs
-  - Canvas/WebGL consistency                    - click / fill / type / scroll
-  - navigator.webdriver = false at C++ source   - screenshot, video record
-  - Humanize mode (mouse curves, timing)        - cookie / state / session mgmt
-```
+For real-Chrome semantics, stealth, traces, or authenticated sessions, WRITE a
+script and run it from the js-eval kernel. Use installed local Chrome, not a
+managed browser download. Ordinary macOS captures on a Bun >= 1.4 kernel use
+`new Bun.WebView()`; Linux/Windows WebView needs installed Chrome/Chromium/Edge.
+Codex's ordinary browser surface is `browser:control-in-app-browser`.
 
 ## Install (one-time)
 
-CloakBrowser runs in a dedicated Python venv. Cross-platform: macOS, Linux, and Windows all supported by both tools (use the venv path convention for your OS).
-
-The venv lives at a fixed path so every session reuses one stealth-Chromium download instead of creating a new venv per working directory, and every command below calls its interpreter by absolute path — no `activate` step to forget.
-
-```bash
-# CloakBrowser (MIT wrapper source; separate binary license, pin 0.5.7):
-VENV="$HOME/.agents/cloak-venv"          # Windows: %USERPROFILE%\.agents\cloak-venv
-uv venv "$VENV" --python 3.13
-uv pip install --python "$VENV/bin/python" "cloakbrowser==0.5.7"
-"$VENV/bin/python" -c "import cloakbrowser; cloakbrowser.ensure_binary()"   # downloads stealth Chromium on first import
+Only the user installs these script dependencies, once in the skill's engine
+directory. Stealth plugins run inside scripts, never inside WebView:
 
-# agent-browser (Apache-2.0, pin 0.34.0):
-bun add -g agent-browser@0.34.0 && agent-browser install
-agent-browser --version   # 0.34.0
+```sh
+cd "$SKILL_DIR/engine"
+test -f package.json || cp templates/package.json package.json
+bun add playwright-core@1.62.1 playwright-extra@4.3.6 puppeteer-extra-plugin-stealth@2.11.2
 ```
 
-Verify CloakBrowser:
-
-```bash
-"$VENV/bin/python" -c "import cloakbrowser; print(cloakbrowser.__version__, cloakbrowser.CHROMIUM_VERSION, cloakbrowser.binary_info()['installed'])"
-# -> 0.5.7  <chromium-version>  True
-```
+Chrome must already be installed. The bundled `templates/playwright_real_chrome.js`
+and `templates/playwright_mobile_chrome.js` resolve these dependencies from their
+parent engine directory. Without optional plugins, templates report the fallback
+and use plain `playwright-core`; do not call that fallback stealth.
 
 ## Launch + drive
 
-NEVER clear cookies, cache, or site data (`Network.clearBrowserCookies`, `Storage.clearCookies`, `chrome.browsingData.remove`, "clear browsing data") on the user's real/main browser profile — it wipes their logged-in state everywhere. If you need that profile's login state, clone it first (`rsync -a <profile>/ <tmp-clone>/`) and launch with the clone as the user-data-dir; run any clearing on the clone only.
-
-```bash
-# 1. Launch CloakBrowser with CDP on :9242 (background). cloakbrowser lives only in the venv,
-#    so call its interpreter by absolute path — this works in any shell, activated or not:
-"$HOME/.agents/cloak-venv/bin/python" -c "import asyncio,cloakbrowser; asyncio.run(cloakbrowser.launch_async(headless=False, stealth_args=True, args=['--remote-debugging-port=9242']))" &
-
-# 2. CloakBrowser launches tabless -> agent-browser would say "No page found".
-#    Open the first tab via CDP before any agent-browser command:
-curl -s -X PUT "http://127.0.0.1:9242/json/new?https://example.com"
-
-# 3. Connect agent-browser. CloakBrowser already patches navigator.webdriver=false at the
-#    C++ source, so NO --init-script is required — only --user-agent to hide HeadlessChrome:
-agent-browser --cdp 9242 \
-  --user-agent "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.7680.177 Safari/537.36" \
-  open https://example.com
-
-# 4. Interact:
-agent-browser --cdp 9242 snapshot -i        # interactive elements (@eN refs)
-agent-browser --cdp 9242 click @e3
-agent-browser --cdp 9242 screenshot out.png
-
-# 5. Close when done:
-agent-browser --cdp 9242 close
+Close the source browser before cloning its user-data directory for a consistent
+copy. Preserve its `Local State` alongside the selected profile. Use a private,
+task-owned clone, never the live user-data-dir. NEVER clear the live profile's
+cookies, cache, or site data. For unauthenticated QA, use a fresh task-owned profile.
+
+Write `capture.cjs` in the engine directory. `clonePath`, URL, and output path are
+arguments owned by this QA run; keep cookie values out of argv and logs:
+
+```js
+const { chromium: core } = require('playwright-core');
+const { addExtra } = require('playwright-extra');
+const stealth = require('puppeteer-extra-plugin-stealth');
+const [clonePath, url, pngPath] = process.argv.slice(2);
+const chromium = addExtra(core);
+chromium.use(stealth());
+
+async function capture() {
+  const context = await chromium.launchPersistentContext(clonePath, {
+    channel: 'chrome',
+    headless: true,
+    args: ['--disable-blink-features=AutomationControlled'],
+    ignoreDefaultArgs: ['--enable-automation'],
+    viewport: { width: 1280, height: 720 },
+  });
+  try {
+    const page = await context.newPage();
+    await page.goto(url, { waitUntil: 'load', timeout: 30000 });
+    await page.screenshot({ path: pngPath });
+    console.log(JSON.stringify({ pngPath, webdriver: await page.evaluate(() => navigator.webdriver) }));
+  } finally {
+    await context.close();
+  }
+}
+capture().catch((error) => { console.error(error); process.exitCode = 1; });
 ```
 
-agent-browser ships its own always-version-matched usage guide — load it instead of guessing flags:
+Run the script from js eval with a bounded process lifetime:
 
-```bash
-agent-browser skills get core            # core workflows, patterns, troubleshooting
-agent-browser skills get core --full     # + full command reference and templates
-agent-browser skills get electron        # Electron apps (VS Code, Slack, Discord, Figma, ...)
-agent-browser skills list                # everything available on the installed version
+```js
+const { promisify } = await import('node:util')
+const { execFile } = await import('node:child_process')
+const result = await promisify(execFile)('node', [scriptPath, clonePath, url, pngPath], { timeout: 45000 })
+console.log(result.stdout)
 ```
 
-## Verify stealth
-
-```bash
-agent-browser --cdp 9242 eval 'navigator.webdriver'   # must print false
-```
+For extraction, run a bundled template the same way, supplying its JSON input on
+stdin (`url`, `profileDir: clonePath`, `waitSelector`, `headless`). The template
+returns HTML on stdout. For traces, use `context.tracing.start()` before navigation
+and `context.tracing.stop({ path: tracePath })` before closing. Use `headless: false`
+only with an available display when headed behavior is the criterion.
 
-Verified 2026-07 with CloakBrowser 0.5.7 + agent-browser 0.34.0: `navigator.webdriver` reads the boolean false with no init-script, bot.sannysoft.com all-green, browserscan.net "Normal" (15/15), nowsecure.nl Turnstile bypassed.
+## Verify stealth
 
-> **agent-browser 0.33.x behavior note:** the daemon now defaults to a 1-hour idle timeout (saves restore state, closes the browser, exits after 1 h of no commands). Set `AGENT_BROWSER_IDLE_TIMEOUT_MS=0` to restore the old always-persist behavior. External WebSocket stream consumers see latest-wins frame delivery; `record` (CDP) and the dashboard are unaffected.
+Inspect the page, screenshot, and requested content. `navigator.webdriver === false`
+checks one browser property, NOT a promise to pass a detector or challenge.
+Persistent challenge pages or missing content are failures, even if the script
+exits zero. Do not keep retrying or silently swap browser tooling.
 
 ## Cookie login (cross-platform)
 
-`scripts/extract_cookies.py` reads cookies from a local browser profile and optionally injects them into the running CDP session. Profile-path resolution and value decryption are per-OS:
+`scripts/extract_cookies.py` exports local-browser cookies with owner-only `0600`
+permissions. Keep exports private and never commit them. For a persistent context,
+load the exported cookies with `context.addCookies(...)`, then navigate/reload.
+Browser- or device-bound login tokens may not transfer to a clone.
 
-| OS | Profile location | Cookie value decryption |
-|----|------------------|--------------------------|
-| macOS | `~/Library/Application Support/<app>/` | Keychain (AES-128-CBC, PBKDF2 salt `saltysalt`) |
-| Linux | `~/.config/<app>/` (Chromium), `~/.mozilla/firefox/` (Firefox) | libsecret/SecretService, then PBKDF2 + AES-128-CBC |
-| Windows | `%LOCALAPPDATA%\<app>\User Data\` | DPAPI (`CryptUnprotectData`) + AES-256-GCM (`os_crypt` key) |
-
-```bash
-# Extract to a file:
-mkdir -p ~/.local/state/omo-cookies
-python3 ../scripts/extract_cookies.py --browser chrome --domain youtube.com --output ~/.local/state/omo-cookies/youtube.cookies.json
-# Extract and inject into the running CDP session:
-python3 ../scripts/extract_cookies.py --browser chrome --domain youtube.com --inject --cdp 9242
-```
-
-Cookie export files are written with owner-only `0600` permissions. Do not place live auth cookies in shared temp directories or commit them to a repo. Cookie injection sends values to CDP over stdin rather than argv, so live cookie values do not appear in process listings. Cookies apply on next navigation — reload after injecting. Google services use fingerprint-bound tokens (SIDTS) that may not transfer across browser profiles. Firefox-family profiles store cookies unencrypted; Chromium-family profiles trigger a one-time OS-keyring prompt on macOS/Linux.
+The helper's `--inject --cdp <port>` targets a task-owned local Chrome CDP endpoint,
+which a script can also use via `chromium.connectOverCDP(...)`. Expose CDP on
+loopback only, never against the live profile. Values travel on stdin, not argv.
 
 ## Anti-patterns
 
-- Do NOT launch CloakBrowser for plain text extraction — use Tier 1.
-- Do NOT pass an `--init-script` for the webdriver flag — CloakBrowser already patches it at source; the only required override is `--user-agent`.
-- Do NOT run agent-browser before creating the first tab via `curl -X PUT .../json/new` — CloakBrowser launches tabless.
-- Do NOT use vanilla Chrome when stealth is needed — always CloakBrowser.
-- Do NOT forget to `close` the session when done.
-- Do NOT inject cookies without reloading the page.
+- Plain text extraction does not need a stealth browser: use the extraction lane.
+- Never launch against, clear, or delete the user's live profile.
+- Never claim stealth from successful startup alone; validate rendered content.
+- Never run plugins without explicit user-installed script dependencies.
 
 ## Troubleshooting
 
-```bash
-# Port 9242 already in use (macOS/Linux):
-lsof -ti:9242 | xargs kill -9
-# agent-browser can't connect:
-curl -s http://127.0.0.1:9242/json/version | head -5   # empty -> CloakBrowser not running
-# Update either tool:
-uv pip install --python "$HOME/.agents/cloak-venv/bin/python" --upgrade "cloakbrowser==0.5.7" && "$HOME/.agents/cloak-venv/bin/python" -c "import cloakbrowser; cloakbrowser.ensure_binary()"
-bun add -g agent-browser@0.34.0
-```
+A missing Chrome executable is a prerequisite failure: report it, do not download
+a replacement. Missing plugins require the one-time setup above; module errors
+inside installed plugins are real failures, not optional-dependency misses.
+A locked profile usually means the source was not cloned or another run owns the
+clone. Use a new task-owned clone instead of killing unrelated browsers.
+
+Always close contexts in `finally`, stop the fixture server, and remove only this
+run's clone and temporary scripts. Preserve requested PNG/trace evidence and record
+the cleanup receipt, including failures.

package/packages/omo-codex/plugin/skills/ultimate-browsing/references/insane-search/README.md

@@ -223,11 +223,17 @@ result = fetch(
 python3 -c "import curl_cffi, bs4, yaml" 2>/dev/null || pip install curl_cffi beautifulsoup4 pyyaml -q
 ```
 
-Playwright 로컬 경로 사용 시 Node가 필요:
+브라우저를 직접 제어할 때는 js eval에서 Bun >= 1.4의 `new Bun.WebView()`를
+사용한다(macOS 기본; Linux/Windows는 설치된 Chrome/Chromium/Edge 필요).
+그 외 또는 Chrome 동작·stealth·trace·인증이 필요하면 `playwright-core` 스크립트를
+작성해 js eval에서 로컬 Chrome(`channel: "chrome"`)으로 실행한다.
+사용자가 엔진 디렉터리에서 한 번 설치할 스크립트 의존성:
 ```bash
-npm i -g playwright playwright-extra puppeteer-extra-plugin-stealth
-npx playwright install chrome
+cd "$SKILL_DIR/engine"
+test -f package.json || cp templates/package.json package.json
+bun add playwright-core@1.62.1 playwright-extra@4.3.6 puppeteer-extra-plugin-stealth@2.11.2
 ```
+Chrome은 이미 설치되어 있어야 한다. 인증 프로필은 먼저 복제하고 복제본만 사용한다.
 
 ## 빠른 참조 — Phase 0 명령어