oh-my-opencode 5.0.0-beta.86 → 5.0.0-beta.87

package/packages/shared-skills/skills/visual-qa/SKILL.md

@@ -49,7 +49,7 @@ Before any reviewer sees an image, verify each capture yourself: the file signat
 ### Web
 
 1. Capture a REFERENCE image: the user's mock/target, generated page snapshot, Figma export, source-site capture, or known-good baseline. Save as PNG. If the user provided overview text or annotations, save them next to the image and treat them as part of the reference packet.
-2. Capture the ACTUAL rendered screenshot at the reference viewport. Use two browser tiers from js eval: (1) `new Bun.WebView()` on Bun >= 1.4 (macOS default; Linux/Windows need installed Chrome/Chromium/Edge); (2) otherwise, or for Chrome semantics, stealth, trace, or authenticated profiles, WRITE a `playwright-core` script and run it from the kernel against local Chrome (`chromium.launch({ channel: "chrome" })` / `launchPersistentContext` on a CLONED profile, never the live one). In Codex, prefer `browser:control-in-app-browser` for ordinary captures. Save PNG and return its path; close the browser context. See `$SKILL_DIR/references/browser-setup.md` for fixed-viewport examples and prerequisites.
+2. Capture the ACTUAL rendered screenshot at the reference viewport with omowright from js eval (the library is staged in the `browser` skill): the owned engine (`connectPipe` on a task-owned profile, viewport pinned with `emulate`, then `page.screenshot()`) for anything unauthenticated, or the attached engine (`connectBrowserSkill()` → `session.screenshot()`) when the page needs the user's login — never a clone of, or a launch against, the user's live profile. Save PNG and return its path; close the browser or stop the session. See `$SKILL_DIR/references/browser-setup.md` for fixed-viewport examples and prerequisites.
 3. Run the diff and keep the JSON:
 
 ```

package/packages/shared-skills/skills/visual-qa/references/browser-setup.md

@@ -1,75 +1,75 @@
 # Browser setup (Web capture)
 
-Use the js-eval kernel for both tiers. In Codex, prefer
-`browser:control-in-app-browser` for ordinary captures.
+Capture with omowright from the js-eval kernel. The library is staged inside the `browser` skill;
+load it once per session:
 
-## Tier 1: Bun.WebView
+```js
+const { loadOmowright } = await import("<browser-skill-root>/scripts/omowright.mjs")
+const { omowright } = await loadOmowright()
+```
+
+## Owned engine (default for QA)
 
-On a Bun >= 1.4 kernel, `new Bun.WebView()` is the macOS default (system
-WebKit, no browser download). Linux/Windows require `backend: "chrome"`
-and installed Chrome/Chromium/Edge. WebView is headless; WebKit has no CDP,
-and `type()` emits no keyboard events. Use tier 2 when these differences matter.
+A browser your code launches, with a task-owned profile, pinned viewport and no user state.
+`connectPipe` opens no listening port and reaps the process on `close()`.
 
 ```js
 // js-eval cell; url and pngPath belong to this QA run.
-const view = new Bun.WebView({ width: 1280, height: 720 })
+const { mkdtempSync, rmSync } = await import("node:fs")
+const profile = mkdtempSync(`${(await import("node:os")).tmpdir()}/visual-qa-`)
+const browser = await omowright.connectPipe({
+  browserPath: chromeBinary,                      // installed Chrome, Chromium, CloakBrowser or chrome-headless-shell
+  browserArgs: ["--headless", "--no-first-run", `--user-data-dir=${profile}`],
+  storageRoot: profile,
+})
 try {
-  await view.navigate(url)
-  await Bun.write(pngPath, await view.screenshot())
+  const page = await browser.newTab("about:blank")
+  await omowright.emulate(page, { width: 1280, height: 720, deviceScaleFactor: 1, mobile: false, hasTouch: false })
+  await page.goto(url, { waitUntil: "load" })
+  await Bun.write(pngPath, await page.screenshot())
   console.log(pngPath)
 } finally {
-  view[Symbol.dispose]()
+  await browser.close()
+  rmSync(profile, { recursive: true, force: true })
 }
 ```
 
-## Tier 2: playwright-core with local Chrome
+Chrome must already be installed; report an absent executable rather than downloading a managed
+browser. For bot-scored or WAF targets use `connectCloakProfile({ profileDir })` (CloakBrowser
+with a pinned fingerprint seed) — the `browser` skill's `references/owned-engine/README.md`
+covers it.
+
+## Attached engine (authenticated pages)
 
-For other kernels, real-Chrome semantics, stealth, traces, or authenticated
-profiles, WRITE a script beside the project's installed `playwright-core`
-dependency and execute it from js eval. The user installs `playwright-core`
-once with `bun add playwright-core` if needed; Chrome must already exist.
-No managed browser download is needed.
+When the capture needs the user's login, drive the browser they are signed into instead of
+cloning its profile:
 
 ```js
-// capture.mjs
-import { chromium } from "playwright-core"
-const [url, pngPath] = process.argv.slice(2)
-const browser = await chromium.launch({ channel: "chrome", headless: true })
+const session = await omowright.connectBrowserSkill({ name: "visual-qa capture", focused: false })
 try {
-  const page = await browser.newPage({ viewport: { width: 1280, height: 720 }, deviceScaleFactor: 1 })
-  await page.goto(url, { waitUntil: "load", timeout: 30000 })
-  await page.screenshot({ path: pngPath })
-  console.log(pngPath)
+  await session.navigate(url, { waitUntil: "load" })
+  await session.resize(1280, 720)
+  const shot = await session.screenshot()            // { buffer, width, height }
+  await Bun.write(pngPath, shot.buffer)
 } finally {
-  await browser.close()
+  await session.stop()
 }
 ```
 
-Run from the js-eval kernel (also works on a Node kernel):
-
-```js
-const { promisify } = await import("node:util")
-const { execFile } = await import("node:child_process")
-const result = await promisify(execFile)("node", [scriptPath, url, pngPath], { timeout: 45000 })
-console.log(result.stdout)
-```
-
-For auth, CLONE the user-data directory to a private task-owned directory
-and use `chromium.launchPersistentContext(clonePath, { channel: "chrome" })`.
-NEVER launch against or clear cookies/cache/site data from the live profile.
-Close the context and remove only the clone after QA. For script-based stealth,
-read the ultimate-browsing skill's `references/chrome-stealth.md`.
+NEVER launch anything against, or clear cookies/cache/site data from, the user's live profile;
+the attached engine is the only sanctioned way to a signed-in page. If no extension is connected,
+run the `browser` skill's `scripts/browser-install.mjs`, relay its one human step, and wait — do
+not fall back to the owned engine for an authenticated criterion.
 
 ## Capture a screenshot at a fixed viewport
 
-Match CSS viewport AND PNG dimensions: WebKit follows native display scale
-(a 1280x720 viewport can yield 2560x1440 pixels). Use matching reference
-captures or Chrome's `deviceScaleFactor`, not resizing to force a pass.
-Wait for the specific page state, not a sleep, then compare:
+Match CSS viewport AND PNG dimensions: pin `deviceScaleFactor` through `emulate` (owned) or
+`resize` (attached) instead of resizing the PNG to force a pass. Wait for the specific page state
+(a locator, a `waitForURL`, a `createNetworkSnoop(page).waitFor(...)`), not a sleep, then compare:
 
 ```sh
 node "$SKILL_DIR/scripts/visual-qa.mjs" image-diff reference.png actual.png
 ```
 
-Inspect `dimensionsMatch` and `diffRatio`, then inspect the image. Close every
-WebView/browser context and the fixture server, even on a failed capture.
+Inspect `dimensionsMatch` and `diffRatio`, then inspect the image. Close every browser and session
+and the fixture server, even on a failed capture; remove the owned profile in the same `finally`.

package/dist/skills/browser/scripts/browser-env.mjs

@@ -1,41 +0,0 @@
-import { execFile } from "node:child_process"
-import { existsSync } from "node:fs"
-import { homedir, platform } from "node:os"
-import { join } from "node:path"
-import { promisify } from "node:util"
-
-const run = promisify(execFile)
-
-export const STORE_LISTINGS = {
-  chrome: "https://chromewebstore.google.com/detail/hhcmgoofomhgciiibhipgmgkgnoenaoi",
-  edge: "https://microsoftedge.microsoft.com/addons/detail/browserskill/emacgiaaaiojkkpkddmmdfhmokgmnikg",
-}
-
-export const SUPPORTED_PLATFORMS = new Set(["darwin", "linux", "win32"])
-
-export function localBinCandidates() {
-  const bin = join(homedir(), ".local", "bin")
-  return platform() === "win32" ? [join(bin, "bsk.exe"), join(bin, "bsk")] : [join(bin, "bsk")]
-}
-
-export async function resolveCli() {
-  for (const candidate of localBinCandidates()) {
-    if (existsSync(candidate)) return candidate
-  }
-  try {
-    await run("bsk", ["--version"], { timeout: 15000, windowsHide: true })
-    return "bsk"
-  } catch {
-    return undefined
-  }
-}
-
-export async function readStatus(cli) {
-  const { stdout } = await run(cli, ["status", "--json"], { timeout: 30000, windowsHide: true })
-  return JSON.parse(stdout)
-}
-
-export function connectedBrowsers(status) {
-  const browsers = status?.browsers
-  return Array.isArray(browsers) ? browsers : []
-}

package/dist/skills/debugging/references/tools/playwright-cli.md

@@ -1,112 +0,0 @@
-# Browser QA — Scripts from js eval
-
-A browser UI bug needs a rendered browser, not curl. Use two tiers from the
-js-eval kernel: `new Bun.WebView()` on Bun >= 1.4 for ordinary captures (macOS
-uses WebKit; Linux/Windows need installed Chrome/Chromium/Edge), otherwise a
-written `playwright-core` script against local Chrome. Use the script tier for
-Chrome semantics, stealth, traces, keyboard events, or authenticated profiles.
-In Codex, prefer `browser:control-in-app-browser` for ordinary page control.
-
-## When to reach for Playwright
-
-Use the script tier for forms, hydration, responsive CSS, cookie/session flows,
-service workers, or client-side navigation. For a backend-only status/body bug,
-use HTTP. WebView is headless, WebKit has no CDP, and `type()` emits no keyboard
-events; choose real Chrome when these distinctions affect the reproduction.
-
-## Install (per-project)
-
-Reuse installed `playwright-core`. If absent, the user can install the script
-dependency once with `bun add playwright-core`. Chrome must already be installed;
-report an absent executable rather than downloading a managed browser. Write the
-script beside the dependency so normal module resolution works.
-
-For stealth, use the ultimate-browsing reference `references/chrome-stealth.md`:
-its optional plugins are user-installed once in the engine directory and executed
-as a script, not injected into WebView.
-
-## The four things you'll actually use
-
-### 1. Write a reproduction script
-
-Record the exact URL, inputs, viewport, expected UI state, and output artifact.
-For auth, CLONE the user-data directory and use `launchPersistentContext` on the
-clone. NEVER launch against or clear data from the live profile.
-
-### 2. Reproduce + capture
-
-```js
-// debug-repro.mjs
-import { chromium } from 'playwright-core';
-const [url, pngPath, tracePath] = process.argv.slice(2);
-const browser = await chromium.launch({ channel: 'chrome', headless: true });
-try {
-  const context = await browser.newContext({ viewport: { width: 1280, height: 720 } });
-  await context.tracing.start({ screenshots: true, snapshots: true });
-  try {
-    const page = await context.newPage();
-    page.on('pageerror', error => console.error(error));
-    await page.goto(url, { waitUntil: 'load', timeout: 30000 });
-    // Add the scenario's actions and locator/state assertions here.
-    await page.screenshot({ path: pngPath });
-    console.log(pngPath);
-  } finally {
-    await context.tracing.stop({ path: tracePath });
-    await context.close();
-  }
-} finally {
-  await browser.close();
-}
-```
-
-A screenshot alone is not a reproduction assertion. Use locators for the exact
-observable state; fail the script when that state is absent.
-
-### 3. Run from the js-eval kernel
-
-```js
-const { promisify } = await import('node:util')
-const { execFile } = await import('node:child_process')
-const result = await promisify(execFile)('node', [scriptPath, url, pngPath, tracePath], { timeout: 60000 })
-console.log(result.stdout)
-```
-
-### 4. Inspect the trace
-
-Retain the trace ZIP for the project's existing trace viewer and inspect the PNG.
-Trace snapshots, network events, and screenshots identify where the UI diverged.
-Keep auth-bearing traces private; do not upload them to public viewers.
-
-## Headless vs headed during debugging
-
-Use `headless: false` with an available display when reproducing headed-only
-behavior. State which mode produced the evidence; do not claim a headless capture
-proves desktop-browser permissions or window behavior.
-
-## Catching the silent-failure patterns Playwright is good at
-
-Subscribe before triggering the action: `page.on('pageerror', ...)`,
-`page.on('requestfailed', ...)`, or a bounded `page.waitForResponse(...)` promise.
-Await that specific response/state rather than sleeping or waiting for generic
-network idleness. Propagate failed assertions and process exit codes.
-
-## Viewport and device emulation
-
-Use `page.setViewportSize({ width: 375, height: 667 })` for a narrow capture.
-`devices` comes from `playwright-core`; apply the desired preset when creating
-a context. Match the reference's pixel scale as well as its viewport.
-
-## Gotchas
-
-- Wait for state, not time: locator visibility or the exact response is the signal.
-- Locators re-resolve after UI changes; stale element handles do not.
-- Fresh task-owned contexts avoid cached state leaking between runs.
-- Auth belongs in a private clone, never the live browser profile.
-- Give every run its own output directory and bounded process lifetime.
-
-## Phase 9 cleanup specifics
-
-Close WebView/browser contexts even on failure, stop the fixture server, and remove
-only this run's temporary scripts and profile clone. Preserve requested PNG/trace
-artifacts, then record the cleanup receipt. Do not kill unrelated browsers or
-remove a user's installed Chrome.

package/dist/skills/programming/scripts/rust/check-no-excuse-rules.py

@@ -1,296 +0,0 @@
-#!/usr/bin/env -S uv run --script
-# /// script
-# requires-python = ">=3.11"
-# dependencies = []
-# ///
-#
-# How to run:
-#   uv run --script check-no-excuse-rules.py src/lib.rs src/main.rs
-#   uv run --script check-no-excuse-rules.py src/           # recursively finds .rs files
-#   uv run --script check-no-excuse-rules.py .              # entire tree
-#
-# No-excuse rule checker for Rust files — Python rewrite of check-no-excuse-rules.sh.
-# Only rules enforceable via pure text matching live here.
-# Everything semantic is on clippy + miri + nextest.
-#
-# Rules:
-#   unwrap            .unwrap() outside tests without // SAFE-UNWRAP:
-#   expect            .expect() outside tests without // SAFE-EXPECT:
-#   placeholder-macro todo!/unimplemented!/unreachable!/unreachable_unchecked! in committed code
-#   box-dyn-error     Box<dyn Error> in non-test code
-#   lib-panic         panic!() in library code
-#   unsafe-no-safety  unsafe { without // SAFETY: in preceding 5 lines
-#   unjustified-clippy-allow  #[allow(clippy::...)] without // CLIPPY-ALLOW:
-#   narrowing-as-cast possible narrowing 'as' cast
-#
-# Opt-out: place the appropriate comment on the previous line:
-#   // SAFE-UNWRAP: <reason>
-#   // SAFE-EXPECT: <reason>
-#   // SAFETY: <reason>          (for unsafe blocks, within 5 lines above)
-#   // CLIPPY-ALLOW: <reason>
-#
-# Test paths (exempt from unwrap/expect/placeholder/box-dyn-error/lib-panic):
-#   tests/, benches/, examples/, build.rs, *_test.rs, #[cfg(test)] regions
-
-from __future__ import annotations
-
-import re
-import sys
-from pathlib import Path
-
-# ---------------------------------------------------------------------------
-# Patterns (compiled once)
-# ---------------------------------------------------------------------------
-
-RE_UNWRAP = re.compile(r"\.unwrap\(\)")
-RE_EXPECT = re.compile(r"\.expect\(")
-RE_PLACEHOLDER = re.compile(r"\b(todo!|unimplemented!|unreachable!|unreachable_unchecked!)")
-RE_BOX_DYN_ERROR = re.compile(r"Box<dyn\s+Error")
-RE_PANIC = re.compile(r"\bpanic!\(")
-RE_UNSAFE_BLOCK = re.compile(r"\bunsafe\s*\{")
-RE_CLIPPY_ALLOW = re.compile(r"#\[allow\(clippy::")
-RE_CFG_TEST = re.compile(r"#\[cfg\(test\)\]")
-RE_SAFE_UNWRAP = re.compile(r"//\s*SAFE-UNWRAP:")
-RE_SAFE_EXPECT = re.compile(r"//\s*SAFE-EXPECT:")
-RE_SAFETY = re.compile(r"//\s*SAFETY:")
-RE_CLIPPY_ALLOW_JUST = re.compile(r"//\s*CLIPPY-ALLOW:")
-
-# Narrowing cast: (wider) as (narrower)
-# Wider types that lose bits when cast to narrower targets.
-# No leading \b — must match e.g. `999u64 as u32` where a digit precedes the type.
-_WIDER = r"(?:u16|u32|u64|u128|usize|i16|i32|i64|i128|isize)"
-_NARROWER = r"(?:u8|u16|u32|i8|i16|i32)"
-RE_NARROWING_CAST = re.compile(
-    rf"{_WIDER}\s+as\s+{_NARROWER}"
-)
-
-# Test-path fragments.
-_TEST_PATH_PARTS = {"tests", "benches", "examples"}
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-violations = 0
-
-
-def report(file: str, line: int, rule: str, detail: str) -> None:
-    """Emit a GitHub-Actions-compatible error annotation to stderr."""
-    global violations
-    print(f"::error file={file},line={line}::[{rule}] {detail}", file=sys.stderr)
-    violations += 1
-
-
-def is_test_path(path: Path) -> bool:
-    """Return True if *path* is in a test/bench/example directory or is a test file."""
-    parts = path.parts
-    for part in parts:
-        if part in _TEST_PATH_PARTS:
-            return True
-    if path.name == "build.rs":
-        return True
-    if path.name.endswith("_test.rs"):
-        return True
-    return False
-
-
-def is_lib_path(file: Path) -> bool:
-    """Heuristic: is this file library code (not main.rs, not src/bin/*)."""
-    parts = path_parts_str(file)
-    # Must live under src/
-    if "src" not in parts:
-        return False
-    if file.name == "main.rs":
-        return False
-    # src/bin/* is binary code
-    try:
-        src_idx = parts.index("src")
-        if src_idx + 1 < len(parts) and parts[src_idx + 1] == "bin":
-            return False
-    except ValueError:
-        return False
-    return True
-
-
-def path_parts_str(p: Path) -> list[str]:
-    return list(p.parts)
-
-
-def strip_line_comment(line: str) -> str:
-    """Return the portion of *line* before any ``//`` line comment.
-
-    This is a crude heuristic — it does not handle ``//`` inside string
-    literals, but matches the behaviour of the bash version.
-    """
-    idx = line.find("//")
-    if idx == -1:
-        return line
-    return line[:idx]
-
-
-def collect_rs_files(args: list[str]) -> list[Path]:
-    """Expand CLI arguments: files are kept as-is, directories are walked."""
-    result: list[Path] = []
-    for arg in args:
-        p = Path(arg)
-        if p.is_file():
-            if p.suffix == ".rs":
-                result.append(p)
-        elif p.is_dir():
-            result.extend(sorted(p.rglob("*.rs")))
-        # Ignore non-existent / non-.rs
-    return result
-
-
-# ---------------------------------------------------------------------------
-# Main checker
-# ---------------------------------------------------------------------------
-
-def check_file(file: Path) -> None:
-    in_test_file = is_test_path(file)
-    in_cfg_test = False
-    cfg_test_brace_depth = 0
-
-    try:
-        lines = file.read_text(encoding="utf-8", errors="replace").splitlines()
-    except OSError as exc:
-        print(f"warning: cannot read {file}: {exc}", file=sys.stderr)
-        return
-
-    for line_no_0, raw_line in enumerate(lines):
-        line_no = line_no_0 + 1  # 1-indexed
-
-        # --- #[cfg(test)] region tracker ---
-        if RE_CFG_TEST.search(raw_line):
-            in_cfg_test = True
-            cfg_test_brace_depth = 0
-
-        if in_cfg_test:
-            opens = raw_line.count("{")
-            closes = raw_line.count("}")
-            cfg_test_brace_depth += opens - closes
-            if cfg_test_brace_depth <= 0 and not RE_CFG_TEST.search(raw_line):
-                in_cfg_test = False
-
-        exempt = in_test_file or in_cfg_test
-        code_only = strip_line_comment(raw_line)
-
-        if not exempt:
-            # .unwrap()
-            if RE_UNWRAP.search(code_only):
-                prev = lines[line_no_0 - 1] if line_no_0 > 0 else ""
-                if not RE_SAFE_UNWRAP.search(prev):
-                    report(
-                        str(file), line_no, "unwrap",
-                        ".unwrap() outside tests - use ? / ok_or / pattern match "
-                        "or annotate previous line with // SAFE-UNWRAP: <reason>",
-                    )
-
-            # .expect(...)
-            if RE_EXPECT.search(code_only):
-                prev = lines[line_no_0 - 1] if line_no_0 > 0 else ""
-                if not RE_SAFE_EXPECT.search(prev):
-                    report(
-                        str(file), line_no, "expect",
-                        ".expect() outside tests - use ? or annotate previous "
-                        "line with // SAFE-EXPECT: <reason>",
-                    )
-
-            # todo!/unimplemented!/unreachable!/unreachable_unchecked!
-            if RE_PLACEHOLDER.search(code_only):
-                report(
-                    str(file), line_no, "placeholder-macro",
-                    "todo!/unimplemented!/unreachable! in committed code",
-                )
-
-            # Box<dyn Error>
-            if RE_BOX_DYN_ERROR.search(code_only):
-                report(
-                    str(file), line_no, "box-dyn-error",
-                    "Box<dyn Error> in non-test code - use anyhow::Error (apps) "
-                    "or thiserror enum (libs)",
-                )
-
-            # panic!() in library code
-            if is_lib_path(file) and RE_PANIC.search(code_only):
-                report(
-                    str(file), line_no, "lib-panic",
-                    "panic!() in library code - return Result",
-                )
-
-        # unsafe { without // SAFETY: — always enforced, even in tests
-        if RE_UNSAFE_BLOCK.search(code_only):
-            start = max(0, line_no_0 - 5)
-            window = "\n".join(lines[start : line_no_0 + 1])
-            if not RE_SAFETY.search(window):
-                report(
-                    str(file), line_no, "unsafe-no-safety-comment",
-                    "unsafe block without // SAFETY: comment in preceding 5 lines",
-                )
-
-        # #[allow(clippy::...)] without // CLIPPY-ALLOW: — always enforced
-        if RE_CLIPPY_ALLOW.search(code_only):
-            prev = lines[line_no_0 - 1] if line_no_0 > 0 else ""
-            if not RE_CLIPPY_ALLOW_JUST.search(prev):
-                report(
-                    str(file), line_no, "unjustified-clippy-allow",
-                    "#[allow(clippy::...)] without // CLIPPY-ALLOW: <reason> on "
-                    "previous line",
-                )
-
-        # Narrowing numeric `as` casts
-        if RE_NARROWING_CAST.search(code_only):
-            report(
-                str(file), line_no, "narrowing-as-cast",
-                "possible narrowing 'as' cast - use TryFrom / try_into() for "
-                "fallible conversion",
-            )
-
-
-# ---------------------------------------------------------------------------
-# Entry point
-# ---------------------------------------------------------------------------
-
-def main() -> None:
-    global violations
-
-    if len(sys.argv) < 2:
-        print(f"Usage: {sys.argv[0]} <file.rs|dir> [file.rs|dir ...]", file=sys.stderr)
-        sys.exit(2)
-
-    files = collect_rs_files(sys.argv[1:])
-    if not files:
-        print("warning: no .rs files found in the given arguments", file=sys.stderr)
-        sys.exit(0)
-
-    for f in files:
-        check_file(f)
-
-    if violations > 0:
-        print("", file=sys.stderr)
-        print(
-            f"rust-programmer: {violations} violation(s). Fix before declaring work done.",
-            file=sys.stderr,
-        )
-        print("", file=sys.stderr)
-        print("Then run the full toolchain gate:", file=sys.stderr)
-        print("  cargo +stable fmt --all -- --check", file=sys.stderr)
-        print(
-            "  cargo +stable clippy --all-targets --all-features -- -D warnings",
-            file=sys.stderr,
-        )
-        print("  cargo nextest run --all-targets --all-features", file=sys.stderr)
-        print(
-            "  cargo +nightly miri nextest run --all-features    # if unsafe touched",
-            file=sys.stderr,
-        )
-        print("  cargo machete", file=sys.stderr)
-        print("  cargo deny check", file=sys.stderr)
-        sys.exit(1)
-
-    print(f"rust-programmer: no-excuse rules passed for {len(files)} file(s).")
-
-
-if __name__ == "__main__":
-    main()

package/packages/omo-codex/plugin/skills/browser/scripts/browser-env.mjs

@@ -1,41 +0,0 @@
-import { execFile } from "node:child_process"
-import { existsSync } from "node:fs"
-import { homedir, platform } from "node:os"
-import { join } from "node:path"
-import { promisify } from "node:util"
-
-const run = promisify(execFile)
-
-export const STORE_LISTINGS = {
-  chrome: "https://chromewebstore.google.com/detail/hhcmgoofomhgciiibhipgmgkgnoenaoi",
-  edge: "https://microsoftedge.microsoft.com/addons/detail/browserskill/emacgiaaaiojkkpkddmmdfhmokgmnikg",
-}
-
-export const SUPPORTED_PLATFORMS = new Set(["darwin", "linux", "win32"])
-
-export function localBinCandidates() {
-  const bin = join(homedir(), ".local", "bin")
-  return platform() === "win32" ? [join(bin, "bsk.exe"), join(bin, "bsk")] : [join(bin, "bsk")]
-}
-
-export async function resolveCli() {
-  for (const candidate of localBinCandidates()) {
-    if (existsSync(candidate)) return candidate
-  }
-  try {
-    await run("bsk", ["--version"], { timeout: 15000, windowsHide: true })
-    return "bsk"
-  } catch {
-    return undefined
-  }
-}
-
-export async function readStatus(cli) {
-  const { stdout } = await run(cli, ["status", "--json"], { timeout: 30000, windowsHide: true })
-  return JSON.parse(stdout)
-}
-
-export function connectedBrowsers(status) {
-  const browsers = status?.browsers
-  return Array.isArray(browsers) ? browsers : []
-}