lazycodex-ai 5.0.0-beta.85 → 5.0.0-beta.87

package/packages/omo-codex/plugin/skills/programming/scripts/rust/new-project.py

@@ -15,8 +15,9 @@
 #      uv run new-project.py myproject --path ./workspace
 # ──────────────────
 #
-# Creates a new Rust project with strict lints, deny.toml, rustfmt.toml,
-# rust-toolchain.toml, and .cargo/config.toml pre-configured.
+# Creates a new Rust project with strict lints, deny.toml, rustfmt.toml, and
+# rust-toolchain.toml pre-configured. The generated project passes its own
+# fmt + clippy gate before any code is written.
 
 from __future__ import annotations
 
@@ -50,6 +51,7 @@ non_ascii_idents = "deny"
 trivial_numeric_casts = "warn"
 unused_lifetimes = "warn"
 single_use_lifetimes = "warn"
+unexpected_cfgs = { level = "deny", check-cfg = ["cfg(loom)"] }
 
 [lints.clippy]
 all = { level = "deny", priority = -1 }
@@ -66,32 +68,22 @@ unimplemented = "deny"
 dbg_macro = "deny"
 print_stdout = "warn"
 print_stderr = "warn"
+allow_attributes = "deny"
+allow_attributes_without_reason = "deny"
+let_underscore_must_use = "deny"
+indexing_slicing = "deny"
+mem_forget = "deny"
+clone_on_ref_ptr = "warn"
 module_name_repetitions = { level = "allow" }
 must_use_candidate = { level = "allow" }
-missing_errors_doc = { level = "allow" }
-missing_panics_doc = { level = "allow" }
-"""
-
-CARGO_CONFIG_TOML = """\
-[build]
-rustflags = ["-C", "link-arg=-fuse-ld=lld"]
-
-[target.x86_64-unknown-linux-gnu]
-linker = "clang"
-rustflags = ["-C", "link-arg=-fuse-ld=lld"]
-
-[target.aarch64-apple-darwin]
-rustflags = []
 """
 
 DENY_TOML = """\
 [advisories]
-vulnerability = "deny"
-unmaintained = "warn"
 yanked = "deny"
 
 [licenses]
-unlicensed = "deny"
+private = { ignore = true }  # publish = false crates carry no license field
 allow = ["MIT", "Apache-2.0", "BSD-2-Clause", "BSD-3-Clause", "ISC", "Unicode-3.0", "Zlib"]
 
 [bans]
@@ -103,6 +95,16 @@ unknown-registry = "deny"
 unknown-git = "deny"
 """
 
+MAIN_RS = """\
+//! Command-line entry point.
+
+use std::io::Write as _;
+
+fn main() -> std::io::Result<()> {
+    writeln!(std::io::stdout().lock(), "Hello, world!")
+}
+"""
+
 RUSTFMT_TOML = """\
 edition = "2024"
 max_width = 100
@@ -148,18 +150,19 @@ def main(
     (project_dir / "rust-toolchain.toml").write_text(RUST_TOOLCHAIN_TOML)
     console.print("  [dim]wrote[/] rust-toolchain.toml")
 
-    # ── Append [lints] to Cargo.toml ─────────────────────────────────
+    # ── Declare the MSRV and append [lints] to Cargo.toml ────────────
     cargo_toml = project_dir / "Cargo.toml"
-    with cargo_toml.open("a") as f:
-        f.write(CARGO_TOML_LINTS)
+    manifest = cargo_toml.read_text()
+    if 'edition = "2024"\n' not in manifest:
+        console.print("[bold red]Error:[/] cargo did not create an edition 2024 package; install Rust >= 1.85")
+        sys.exit(1)
+    manifest = manifest.replace(
+        'edition = "2024"\n', 'edition = "2024"\nrust-version = "1.85"\npublish = false\n', 1
+    )
+    cargo_toml.write_text(manifest + CARGO_TOML_LINTS)
+    (project_dir / "src" / "main.rs").write_text(MAIN_RS)
     console.print("  [dim]appended[/] [lints] to Cargo.toml")
 
-    # ── .cargo/config.toml ───────────────────────────────────────────
-    cargo_config_dir = project_dir / ".cargo"
-    cargo_config_dir.mkdir(parents=True, exist_ok=True)
-    (cargo_config_dir / "config.toml").write_text(CARGO_CONFIG_TOML)
-    console.print("  [dim]wrote[/] .cargo/config.toml")
-
     # ── deny.toml ────────────────────────────────────────────────────
     (project_dir / "deny.toml").write_text(DENY_TOML)
     console.print("  [dim]wrote[/] deny.toml")

package/packages/omo-codex/plugin/skills/review-work/SKILL.md

@@ -169,7 +169,7 @@ You are the QA lane. Do not delegate hands-on QA to a sub-agent: the orchestrato
 2. **Pick the channel that faithfully exercises the surface** and capture the artifact:
    - HTTP: `curl -i` (or an API request context) - status line, headers, body.
    - CLI / TUI: a real pty - drive the command and keep the transcript; for color or layout evidence render through a browser-based terminal, never a `tmux capture-pane` dump.
-   - Web: from js eval, use `new Bun.WebView()` on Bun >= 1.4 (macOS default; Linux/Windows need Chrome/Chromium/Edge). Otherwise, or for Chrome semantics, stealth, trace, or auth, write and run a `playwright-core` script against local Chrome (`channel: "chrome"`; persistent context on a CLONED profile). Codex: `browser:control-in-app-browser`. Capture action log plus screenshot.
+   - Web: omowright from js eval (staged in the `browser` skill) — the owned engine (`connectPipe` on a task-owned profile, or `connectCloakProfile` for bot-scored targets) for unauthenticated pages, the attached engine (`connectBrowserSkill()` in the user's signed-in browser) when the page needs their login; never a clone of or a launch against the live profile. Capture action log plus screenshot.
    - Desktop / GUI: OS-level automation against the running app - action log plus screenshot.
    - Library / SDK: a script that imports and exercises the public API - transcript.
    - Data-shaped work (migrations, configs, generated files): the resulting artifact itself, diffed or dumped.

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

@@ -7,7 +7,7 @@ description: "Renders, drives, and screenshots web pages: JS-rendered sources, c
 
 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 Bun.WebView, 2b a local-Chrome `playwright-core` script from js eval for Chrome semantics, stealth, trace, or auth.
+**Tier 1 — insane-search** (headless extraction + WAF bypass) -> **Tier 1.5 — agent-reach** (platform-native APIs, esp. Chinese platforms) -> **Tier 2 — a real browser** through omowright from js eval: 2a the owned engine (a browser your code launches, CloakBrowser for stealth), 2b the attached engine (the user's own signed-in browser).
 
 ## PHASE 0 — ROUTE FIRST (MANDATORY)
 
@@ -23,11 +23,11 @@ User request
   +- podcast transcript / stock forum ----------------- TIER 1.5 agent-reach
   +- Twitter feed / LinkedIn profile / GitHub via CLI - TIER 1.5 agent-reach
   |
-  +- Tier 1/1.5 returned empty or partial ------------- TIER 2  2a kernel browser -> 2b stealth
-  +- click / fill form / scroll / interact ------------ TIER 2  2a kernel browser -> 2b stealth
-  +- screenshot / render / play video ----------------- TIER 2  2a kernel browser -> 2b stealth
-  +- login session across pages / inject cookies ------ TIER 2  2b Chrome stealth (profile + cookies)
-  +- test web app / QA / dogfood ---------------------- TIER 2  2a kernel browser -> 2b stealth
+  +- Tier 1/1.5 returned empty or partial ------------- TIER 2  2a owned engine -> 2b attached engine
+  +- click / fill form / scroll / interact ------------ TIER 2  2a owned engine -> 2b attached engine
+  +- screenshot / render / play video ----------------- TIER 2  2a owned engine -> 2b attached engine
+  +- login session across pages / the user's account --- TIER 2  2b attached engine (their browser)
+  +- test web app / QA / dogfood ---------------------- TIER 2  2a owned engine -> 2b attached engine
   |
   +- simple search query ------------------------------ NOT this skill (use web-search)
 ```
@@ -84,28 +84,35 @@ Routing table, per-platform auth (set `TWITTER_*` env vars, `gh auth login`, a t
 
 **When**: real interaction is needed (clicks, forms, screenshots, video, persistent login), or Tier 1/1.5 failed.
 
-### Tier 2a — kernel browser (default)
+Both tiers are omowright, staged inside the `browser` skill and loaded from js eval:
 
-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
+const { loadOmowright } = await import("<browser-skill-root>/scripts/omowright.mjs")
+const { omowright } = await loadOmowright()
+```
+
+### Tier 2a — owned engine (default)
+
+A browser your code launches with a task-owned profile. `connectPipe` opens no listening port; `connectCloakProfile` launches CloakBrowser with a pinned fingerprint seed and is the path for WAF, Cloudflare and bot-scored pages.
 
 ```js
-const view = new Bun.WebView({ width: 1280, height: 800 })
+const browser = await omowright.connectPipe({ browserPath, browserArgs: ["--headless", `--user-data-dir=${profile}`], storageRoot: profile })
 try {
-  await view.navigate(url)
-  const title = await view.evaluate("document.title")
-  await Bun.write(pngPath, await view.screenshot())
+  const page = await browser.newTab(url)
+  const tree = omowright.compactSnapshot(await page.snapshot())   // the read; refs come from it
+  const snoop = omowright.createNetworkSnoop(page)                  // read the API JSON instead of the DOM when there is one
+  await page.locator("e3").click()
+  await Bun.write(pngPath, await page.screenshot())
 } finally {
-  view[Symbol.dispose]()
+  await browser.close()                                            // then rm -rf the profile
 }
 ```
 
-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)
+The rest of the surface (CUA coordinates, captcha solving, routes, traces, frames, human handoff) is in the `browser` skill's `references/owned-engine/`. A stealth binary is not proof of access: inspect the rendered result and report challenges that remain.
 
-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.
+### Tier 2b — attached engine (logged-in pages)
 
-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.
+When the page needs the user's account, drive the browser they are already signed into instead of cloning their profile: `connectBrowserSkill()` → `session.navigate` → `bskSnapshot(session)` / `session.observe()` → `session.click` → `session.stop()`. NEVER launch against or clear cookies/cache/site data from the user's live profile, and never fall back to the owned engine for an authenticated criterion: if no extension is connected, run the `browser` skill's onboarding script and relay its one human step. The full loop is the `browser` skill.
 
 ### Cookie login (cross-platform)
 
@@ -119,7 +126,7 @@ python3 scripts/extract_cookies.py --browser chrome --domain youtube.com --outpu
 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. Cookies apply on next navigation — reload after injecting. Google services use fingerprint-bound tokens that may not transfer across browser profiles. Full detail in [references/chrome-stealth.md](references/chrome-stealth.md).
+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. Cookies apply on next navigation — reload after injecting. Google services use fingerprint-bound tokens that may not transfer across browser profiles. Limits in [references/chrome-stealth.md](references/chrome-stealth.md).
 
 ## Reference docs
 
@@ -127,7 +134,7 @@ 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 playwright-core scripts, optional stealth setup, cloned profiles, cookie login |
+| [references/chrome-stealth.md](references/chrome-stealth.md) | Tier-2 stealth through omowright + CloakBrowser, cookie login limits |
 
 ## Environment variables
 

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

@@ -65,7 +65,7 @@ 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 (Bun.WebView / local-Chrome playwright-core scripts from js eval).
+  (agent-reach) and Tier 2 (omowright from js eval: owned and attached engines via the `browser` skill).
   Upstream has no such tiering.
 
 ### WANT — upstream improvements worth porting forward

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

@@ -1,113 +1,45 @@
-# Tier 2 — Chrome stealth through playwright-core scripts
+# Tier 2 — stealth through omowright and CloakBrowser
 
-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`.
+For real-Chrome semantics, stealth, traces, or authenticated sessions, drive omowright from the
+js-eval kernel. The library is staged inside the `browser` skill; load it with
+`loadOmowright()` from that skill's `scripts/omowright.mjs`.
 
-## Install (one-time)
+## Stealth is the engine, not a plugin
 
-Only the user installs these script dependencies, once in the skill's engine
-directory. Stealth plugins run inside scripts, never inside WebView:
-
-```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
-```
-
-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
-
-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:
+Bot-scored pages (Cloudflare Turnstile, FingerprintJS, DataDome) are handled by launching
+**CloakBrowser** — a Chromium build with source-level fingerprint patches — through
+`connectCloakProfile({ profileDir })`. The profile pins a fingerprint seed on first use and
+refuses to change identity silently, so the same site sees the same browser on every run.
 
 ```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();
-  }
+const browser = await omowright.connectCloakProfile({ profileDir })
+try {
+  const page = await browser.newTab(url)
+  console.log(await page.evaluate("navigator.webdriver"))     // must be false
+  await Bun.write(pngPath, await page.screenshot())
+} finally {
+  await browser.close()
 }
-capture().catch((error) => { console.error(error); process.exitCode = 1; });
-```
-
-Run the script from js eval with a bounded process lifetime:
-
-```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)
 ```
 
-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.
-
-## Verify stealth
-
-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` 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.
-
-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.
+Do not pass an init-script for `navigator.webdriver` and do not add stealth plugins: CloakBrowser
+patches the engine itself. A launch that still meets a challenge is handled by the `browser`
+skill's ladder (`references/owned-engine/ladder.md`: layers, coordinates, `createCaptcha`), and a
+page that only a signed-in user can reach belongs to the attached engine, not to a cloned profile.
 
-## Anti-patterns
+## Cookie login limits
 
-- 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.
+`scripts/extract_cookies.py` still exports cookies from a local browser; inject them with
+`injectCookies(page, cookies)` into an **owned** profile. It sanitizes the set (drops expired
+entries, keeps host-prefixed cookies secure and root-scoped). Limits that do not change:
 
-## Troubleshooting
+- Accounts whose risk engines bind a session to a device (Google, password managers) invalidate a
+  session reused from a new fingerprint; use the attached engine for those.
+- Cookies apply on the next navigation — reload after injecting.
+- NEVER copy a session out of, or clear cookies/cache/site data in, the user's live profile.
 
-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.
+## The extraction engine's own Playwright fallback
 
-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.
+The Tier-1 Python engine (`engine/`) keeps its own script-based Chrome fallback for headless
+extraction; that is an engine internal, not an agent-facing browser path. Interactive work, QA and
+screenshots go through omowright as above.

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

@@ -223,17 +223,11 @@ result = fetch(
 python3 -c "import curl_cffi, bs4, yaml" 2>/dev/null || pip install curl_cffi beautifulsoup4 pyyaml -q
 ```
 
-브라우저를 직접 제어할 때는 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
-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은 이미 설치되어 있어야 한다. 인증 프로필은 먼저 복제하고 복제본만 사용한다.
+브라우저를 직접 제어할 때는 js eval에서 omowright를 쓴다(`browser` 스킬에 스테이징됨):
+직접 띄우는 브라우저는 `connectPipe` / 스텔스는 `connectCloakProfile`(CloakBrowser),
+사용자가 로그인해 둔 브라우저는 `connectBrowserSkill`. 이 엔진의 Playwright 템플릿은
+Tier 1 추출 폴백 전용이며 에이전트가 직접 브라우저를 다루는 경로가 아니다.
+인증이 필요한 페이지는 사용자 프로필을 복제하지 말고 attached 엔진으로 간다.
 
 ## 빠른 참조 — Phase 0 명령어
 

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

@@ -17,9 +17,9 @@
 ### 의존성
 
 이 항목은 이미 연결된 MCP를 사용하는 엔진 어댑터의 설명이다.
-새 브라우저 세션은 js eval의 Bun.WebView(Bun >= 1.4, macOS 기본;
-Linux/Windows는 설치된 Chrome/Chromium/Edge 필요), 그 외 또는 Chrome 동작·stealth·trace·인증은
-로컬 Chrome을 제어하는 `playwright-core` 스크립트로 실행한다. MCP를 새로 설치하지 않는다.
+에이전트가 직접 여는 브라우저 세션은 js eval의 omowright(`browser` 스킬에 스테이징)로
+띄운다: 직접 소유 브라우저는 `connectPipe`, 스텔스는 `connectCloakProfile`, 사용자 로그인이
+필요하면 `connectBrowserSkill`. MCP를 새로 설치하지 않는다.
 
 ### 기본 워크플로
 
@@ -52,15 +52,14 @@ Linux/Windows는 설치된 Chrome/Chromium/Edge 필요), 그 외 또는 Chrome
 
 ### 의존성 (최초 1회)
 
-```bash
-# Node (시스템 설치)
-node -v   # v18+ 권장
+엔진 템플릿의 스크립트 의존성은 `engine/templates/package.json`에 고정되어 있다.
+엔진 디렉터리에서 한 번만 설치한다. Chrome은 이미 시스템에 설치되어 있어야 하며,
+브라우저 다운로드 명령은 없다.
 
-# 사용자가 엔진 디렉터리에서 한 번 설치하는 스크립트 의존성
+```bash
 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은 이미 시스템에 설치되어 있어야 한다. 브라우저 다운로드 명령은 없다.
+bun install
 ```
 
 ### 호출 (engine 내부)
@@ -76,39 +75,23 @@ attempt, html = run_playwright_fallback(
 )
 ```
 
-내부에서 `engine/templates/playwright_real_chrome.js` 또는 `playwright_mobile_chrome.js`를 Node로 실행하고 HTML을 받아온다. 템플릿은 **URL과 셀렉터 파라미터만** 받으며 사이트별 분기가 없다.
+내부에서 `engine/templates/playwright_real_chrome.js` 또는 `playwright_mobile_chrome.js`를 Node로 실행하고 HTML을 받아온다. 템플릿은 **URL과 셀렉터 파라미터만** 받으며 사이트별 분기가 없다. 템플릿은 엔진이 실행하는 프로그램이다. 에이전트가 이 템플릿을 본떠 브라우저 스크립트를 새로 쓰지 않는다.
 
 ### 데스크톱 템플릿 (`playwright_real_chrome.js`)
 
-```js
-const { addExtra } = require('playwright-extra');
-const chromium = addExtra(require('playwright-core').chromium);
-const stealth = require('puppeteer-extra-plugin-stealth')();
-chromium.use(stealth);
-
-const ctx = await chromium.launchPersistentContext(profileDir, {
-  channel: 'chrome',        // ← 핵심: 번들 Chromium 아닌 실제 Chrome
-  headless: false,          // Akamai는 headless 탐지. headful 필요.
-  viewport: { width: 1366, height: 900 },
-});
-```
+- 번들 Chromium이 아니라 **시스템에 설치된 실제 Chrome**을 띄운다. TLS 지문이 실제 Chrome이 되는 것이 핵심이다.
+- stealth 플러그인을 적용하고, 작업 전용 영속 프로필 디렉터리를 쓴다.
+- Akamai는 headless를 탐지하므로 **headful**로 실행하고, 뷰포트는 1366×900이다.
 
 ### 모바일 템플릿 (`playwright_mobile_chrome.js`)
 
-```js
-const { devices } = require('playwright-core');
-const { addExtra } = require('playwright-extra');
-const chromium = addExtra(require('playwright-core').chromium);
-const iPhone = devices['iPhone 13 Pro'];
-
-const ctx = await chromium.launchPersistentContext(profileDir, {
-  channel: 'chrome',          // TLS는 실제 Chrome
-  ...iPhone,                  // UA/viewport/isMobile/hasTouch 자동 주입
-  headless: false,
-});
-```
+- TLS는 데스크톱과 같은 실제 Chrome이고, iPhone 13 Pro 디바이스 기술자(UA/viewport/isMobile/hasTouch)만 주입한다. headful로 실행한다.
+
+**주의**: 실제 Chrome + 모바일 디바이스 기술자 조합은 TLS 핑거프린트를 Chrome으로 유지하면서 HTTP 레이어(UA/viewport)만 모바일로 바꾼다. WAF가 실제 Chrome으로 인식해서 관대한 경우가 많다.
+
+### 엔진 밖에서 같은 효과가 필요할 때
 
-**주의**: `channel:'chrome'` + `devices[...]` 조합은 TLS 핑거프린트를 Chrome으로 유지하면서 HTTP 레이어(UA/viewport)만 모바일로 바꾼다. WAF가 실제 Chrome으로 인식해서 관대한 경우가 많다.
+엔진 폴백이 아니라 에이전트가 직접 페이지를 조작해야 한다면 js eval에서 omowright(`browser` 스킬에 스테이징)를 쓴다. 지문이 고정된 스텔스 브라우저는 `connectCloakProfile({ profileDir })`, 모바일 뷰는 `emulate(page, "iphone-14")`, 사용자 로그인이 필요하면 `connectBrowserSkill()`이다.
 
 ## 선택 규칙 (자동)
 
@@ -129,8 +112,8 @@ const ctx = await chromium.launchPersistentContext(profileDir, {
 
 ## 디버깅 팁
 
-- 템플릿은 js eval에서 스크립트로 실행한다. `profileDir`는 작업 전용 경로나 사용자 프로필의 복제본만 사용한다.
-- 사용자의 실제 프로필을 실행·초기화·삭제하지 않는다. 작업 종료 시 컨텍스트를 닫고 작업 전용 복제본만 정리한다.
+- 템플릿의 `profileDir`는 작업 전용 경로만 사용한다. 사용자의 실제 프로필을 실행·복제·초기화·삭제하지 않는다.
+- 작업 종료 시 브라우저를 닫고 작업 전용 프로필만 정리한다.
 - 실패 시 `result.trace`의 `error` 필드에 Node stderr 200자가 포함됨
 
 ## 사이트 예시 (독자 이해용, 코드 분기 근거 아님)