lazycodex-ai 5.1.44 → 5.1.46

package/packages/shared-skills/skills/browser/references/commands.md

@@ -98,17 +98,10 @@ Every refusal is a `BskRpcError` with the daemon's own `code`:
 | `invalid_params` | wrong option shape | fix the call, do not retry as-is |
 | `permission_denied` | `evaluate` on a tab outside the Agent Window, or a denied borrow | stop; the user said no |
 | `timeout` | the tool did not finish in its budget | read the page state before retrying once |
-| `user_aborted` | the user pressed Stop in the browser | stop the task and report; under `OMO_BROWSER_ENGINE` this surfaces as `BrowserUserStoppedError` and no session starts again this turn |
+| `user_aborted` | the user pressed Stop in the browser | stop the task and report |
 | `cdp_failed` | the page cannot be attached (restricted URL, DevTools open) | say which page and why |
 
-Typed errors under `OMO_BROWSER_ENGINE` (see SKILL.md Step 0):
-
-| Error | `code` | Meaning |
-|---|---|---|
-| `BrowserNotConnectedError` | `browser_not_connected` | the user's browser is not connected; ask them to connect it |
-| `BrowserEngineRefusal` | `browser_engine_none` / `browser_engine_builtin` / `browser_engine_unsupported` / `browser_tool_blocked` | this engine setting does not allow that call |
-| `BrowserActionDeclinedError` | `user_declined` | the user said no, or no question could be asked; do not retry |
-| `BrowserUserStoppedError` | `user_stopped` | the user stopped browser use |
+Inside OmO Desktop (`OMO_BROWSER_ENGINE` set), `connectBuiltinBrowser()` throws `BuiltinBrowserUnavailableError` (`code` `browser_builtin_unavailable`). Reasons `unavailable`, `timeout`, and `invalid_grant` mean the built-in browser is unavailable; `invalid_grant` includes a missing or unreadable token file. For `user_stopped` or any other app refusal, stop browser work and report it without opening another browser. Refresh uses the new grant's endpoint and token together; every other call behaves as in the terminal.
 
 Long calls can be cancelled: `const h = session.client.callWithHandle("tool.navigate", {...})`
 then `await session.client.cancel(h.rpcId)`.

package/packages/shared-skills/skills/browser/references/install.md

@@ -11,8 +11,7 @@ Three pieces. The onboarding script prepares all three; a human finishes exactly
 ## Inside the OmO desktop app
 
 The app installs the `bsk` CLI and starts its daemon itself, and keeps the daemon running when the app closes.
-Do not run `browser-install.mjs` there unless the doctor says the app's engine is missing; a session set to
-`OMO_BROWSER_ENGINE=builtin` or `none` never uses this skill's attached engine at all. `BSK_HOME` and `BSK_BIN`
+Do not run `browser-install.mjs` there unless the doctor says the app's engine is missing. `BSK_HOME` and `BSK_BIN`
 still decide where the CLI and daemon are found, here and everywhere else.
 
 ## Supported

package/packages/shared-skills/skills/browser/runtime/omowright/manifest.json

@@ -5,5 +5,5 @@
     "index.js": "d67d3a847fe0bbc43e824feded48b280890d31879538309e671cd5f671133995",
     "page-bundle.js": "bfd51e8383cf47200d57387bbbed258bce5a3a3d00c38fc108034d2888e23f0c"
   },
-  "stagedAtUtc": "2026-10-23T05:07:41.453Z"
+  "stagedAtUtc": "2026-10-25T01:02:39.752Z"
 }

package/packages/shared-skills/skills/browser/scripts/browser-doctor.mjs

@@ -19,7 +19,7 @@ const state = report.ready
 
 const REMEDIES = {
   ready: "Attached engine is live: const { connectBrowserSkill } = await import(omowrightEntry); const session = await connectBrowserSkill({ name: \"<task>\", focused: false })",
-  "no-cli": "Run node \"<skill-root>/scripts/browser-install.mjs\" — it installs the CLI, starts the daemon and registers the extension; then tell the user the single step it prints.",
+  "no-cli": "Run node \"<skill-root>/scripts/browser-install.mjs\". It installs the CLI, starts the daemon and registers the extension; then tell the user the single step it prints.",
   "no-daemon": "Run node \"<skill-root>/scripts/browser-install.mjs\" (it starts the daemon through `bsk status`), then re-run this doctor.",
   "no-extension": report.nextStep ?? "Register the extension with browser-install.mjs, then relay its human step to the user and re-run this doctor.",
   "choose-browser": `Do not install anything yet. First check your memory for the browser this user works in; if it names one of the candidates, re-run with --browser=<id>. Otherwise ask the user which browser they actually use (${report.identification.reason}), record the answer in memory, then run node "<skill-root>/scripts/browser-install.mjs" --browser=<id>.`,
@@ -47,7 +47,7 @@ if (process.argv.includes("--json")) {
   console.log(`state: ${state}`)
   console.log(`omowright: ${entry}`)
   console.log(`cli: ${report.cli.installed ? `${report.cli.bskBin} (${report.cli.version})` : "not installed"}`)
-  console.log(`daemon: ${report.daemon.running ? `running (${report.daemon.version}, protocol ${report.daemon.protocolVersion})` : `not running${report.daemon.error ? ` — ${report.daemon.error}` : ""}`}`)
+  console.log(`daemon: ${report.daemon.running ? `running (${report.daemon.version}, protocol ${report.daemon.protocolVersion})` : `not running${report.daemon.error ? ` - ${report.daemon.error}` : ""}`}`)
   console.log(`browser the user uses: ${summary.browser ? `${summary.browser.label} [${summary.browser.id}] (${summary.browser.reason})` : `not identified (${report.identification.reason})`}`)
   console.log(`candidates: ${summary.candidates.map((c) => `${c.id}${c.signals.length ? ` (${c.signals.join(", ")})` : ""}`).join(", ") || "none"}`)
   if (summary.registeredElsewhere.length > 0) console.log(`extension entries left in other browsers: ${summary.registeredElsewhere.join(", ")} (not removed automatically)`)

package/packages/shared-skills/skills/browser/scripts/browser-engine-guard.mjs

@@ -1,506 +1,82 @@
-export const BROWSER_CONFIRMATION_POLICY = "ask-before-irreversible"
-export const BROWSER_ENGINE_ENV = "OMO_BROWSER_ENGINE"
-export const BROWSER_STATE_EVENT = "omo.browser.state"
-
-const BRIDGE_TOOL = "omo_browser_bridge"
-const ENGINES = new Set(["connected", "builtin", "none"])
-const NOT_CONNECTED_CODES = new Set(["no_browser_connected", "no_daemon", "unsupported"])
-const CLASSIFY_HTML_BYTES = 4096
-const QUESTION_HEADER = "Browser"
-const ALLOW = "Allow"
-const DECLINE = "Don't allow"
-const READ_ONLY_RAW_TOOLS = new Set(["observe", "snapshot", "get_html", "screenshot", "tab_list", "console", "network"])
-
-const OWNED_SESSION_CREATORS = new Set(["connect", "connectPipe", "connectCloakProfile"])
-const PASSTHROUGH_FUNCTIONS = new Set([
-  "bskDoctor",
-  "bskOnboard",
-  "installBskCli",
-  "readDaemonInfo",
-  "resolveBskHome",
-  "listBrowsers",
-  "catalogBrowsers",
-  "detectBrowsers",
-  "identifyBrowser",
-  "probeBrowserSignals",
-  "findCloakBrowserPath",
-  "resolveCloakProfile",
-  "registerExternalExtension",
-  "unregisterExternalExtension",
-  "externalExtensionEntry",
-  "buildSnapshotExpression",
-  "buildCloakBrowserArgs",
-  "compactSnapshot",
-  "snapshotTokens",
-  "describeLayers",
-  "layersHeader",
-  "decodeFrames",
-  "encodeFrame",
-  "reconcileFrames",
-  "normalizeDialogPolicy",
-  "resolveDialogAction",
-  "sanitizeCookies",
-  "toHar",
-  "BskRpcError",
-  "BridgeProtocolError",
-  "BridgeUnavailableError",
-  "BrowserCdpCommandError",
-  "UnsupportedOperationError",
-])
-
-class CodedError extends Error {
-  constructor(name, code, message, options) {
-    super(message, options)
-    this.name = name
-    this.code = code
-  }
-}
-
-export class BrowserEngineRefusal extends CodedError {
-  constructor(code, message) {
-    super("BrowserEngineRefusal", code, message)
-  }
-}
-
-export class BrowserNotConnectedError extends CodedError {
-  constructor(message, options) {
-    super("BrowserNotConnectedError", "browser_not_connected", message, options)
-  }
-}
-
-export class BrowserUserStoppedError extends CodedError {
-  constructor(message = "The user stopped browser use. Report that and do not start another browser session this turn.") {
-    super("BrowserUserStoppedError", "user_stopped", message)
-  }
-}
-
-export class BrowserActionDeclinedError extends CodedError {
-  constructor(message, code = "user_declined") {
-    super("BrowserActionDeclinedError", code, message)
-  }
-}
-
-const IRREVERSIBLE_LABELS = [
-  /\b(send|post|publish|tweet|reply)\b/i,
-  /\b(pay|purchase|buy|subscribe|donate|checkout|submit|confirm|transfer|approve|merge)\b/i,
-  /\b(e-?sign|sign\s+(the\s+|this\s+|your\s+)?(document|contract|agreement|transaction|petition|form))\b/i,
-  /\border\b(?!\s+(history|status|details|number|tracking))/i,
-  /\b(delete|remove|unsubscribe|deactivate)\b/i,
-  /\bcancel\s+(my\s+|your\s+)?(subscription|membership|plan|account)\b/i,
-  /\bclose\s+(my\s+|your\s+)?account\b/i,
-  /결제|구매|주문|구독|삭제|제거|탈퇴|전송|발송|게시|발행|제출|승인|송금|이체|병합/,
-]
-const IRREVERSIBLE_ACTION_PATH = /\/(send|post|publish|pay|purchase|order|subscribe|delete|remove)\b/i
-const SCRIPT_DRIVES_UI = /\.(click|submit|requestSubmit)\s*\(|\bdispatchEvent\b/
-const SCRIPT_BEACON = /\bsendBeacon\s*\(/
-const SCRIPT_REACHES_NETWORK = /\b(fetch|XMLHttpRequest)\b/
-const SCRIPT_WRITES = /["'`](POST|PUT|PATCH|DELETE)["'`]/i
-const ENTER_KEY = /(^|\+)(Enter|Return)$/i
-const SENDING_CHORD = /(^|\+)(Control|Ctrl|Meta|Cmd|Command)\+/i
-
-export function isIrreversibleLabel(label) {
-  return typeof label === "string" && IRREVERSIBLE_LABELS.some((pattern) => pattern.test(label))
-}
-
-function labelsOf(descriptor) {
-  return [descriptor?.text, descriptor?.ariaLabel, descriptor?.title, descriptor?.value].filter((label) => typeof label === "string" && label.length > 0)
-}
-
-function markupIsEditable(html) {
-  return /\bcontenteditable\b(?!\s*=\s*["']?false)|\brole\s*=\s*["']textbox["']|<textarea\b/i.test(html)
-}
-
-function labelsFromMarkup(html) {
-  const labels = []
-  for (const match of html.matchAll(/\b(?:aria-label|title|value|alt)\s*=\s*"([^"]*)"/gi)) labels.push(match[1])
-  labels.push(html.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim())
-  return labels.filter((label) => label.length > 0)
-}
+import { readFile } from "node:fs/promises"
 
-function scriptNeedsConfirmation(expression) {
-  if (typeof expression !== "string") return false
-  if (SCRIPT_DRIVES_UI.test(expression) || SCRIPT_BEACON.test(expression)) return true
-  return SCRIPT_REACHES_NETWORK.test(expression) && SCRIPT_WRITES.test(expression)
-}
-
-function describeElementExpression(selector) {
-  return `(function (selector) {
-  const el = selector ? document.querySelector(selector) : document.activeElement
-  if (!el || el === document.body || el === document.documentElement) return null
-  const text = (el.innerText || el.textContent || "").trim().slice(0, 200)
-  const form = el.form || (el.closest ? el.closest("form") : null)
-  return {
-    tag: el.localName,
-    editable: el.isContentEditable === true || el.localName === "textarea" || el.getAttribute("role") === "textbox",
-    text,
-    ariaLabel: el.getAttribute("aria-label") || undefined,
-    title: el.getAttribute("title") || undefined,
-    value: el.localName === "button" || (el.localName === "input" && /^(submit|button|image)$/i.test(el.type)) ? el.value : undefined,
-    form: form ? {
-      action: form.getAttribute("action") || "",
-      method: (form.getAttribute("method") || "get").toLowerCase(),
-      submitLabels: Array.from(form.querySelectorAll("button, input[type=submit], input[type=image]")).filter((b) => (b.type || "submit") === "submit").map((b) => (b.innerText || b.value || b.getAttribute("aria-label") || "").trim().slice(0, 100)),
-    } : undefined,
-  }
-})(${JSON.stringify(selector ?? null)})`
-}
-
-function codeOf(error) {
-  return typeof error?.code === "string" ? error.code : error instanceof Error ? error.name : "error"
-}
-
-function targetKind(target) {
-  if (typeof target === "string") return /^@?e\d+$/.test(target) ? { kind: "ref", ref: target } : { kind: "selector", selector: target }
-  if (target && typeof target === "object") {
-    if (typeof target.ref === "string") return { kind: "ref", ref: target.ref }
-    if (typeof target.selector === "string") return { kind: "selector", selector: target.selector }
-  }
-  return { kind: "point" }
-}
-
-function createBridge(host, context) {
-  const call = async (args) => {
-    if (host === undefined) return undefined
-    try {
-      const result = await host.callTool(BRIDGE_TOOL, args)
-      return result?.hasError === true ? undefined : result
-    } catch {
-      return undefined
-    }
-  }
-  return {
-    async emit(status, extra = {}) {
-      const data = { engine: context.engine, status }
-      if (context.sessionId !== undefined) data.session = context.sessionId
-      for (const [key, value] of Object.entries(extra)) if (value !== undefined) data[key] = value
-      await call({ op: "state", data })
-    },
-    async stopped() {
-      return (await call({ op: "status" }))?.details?.stopped === true
-    },
-    async markStopped() {
-      await call({ op: "stopped" })
-    },
-  }
-}
-
-function describeTab(tab) {
-  if (!tab || typeof tab !== "object") return undefined
-  const favicon = tab.favicon_url ?? tab.faviconUrl ?? tab.favIconUrl ?? tab.favicon
-  const described = { id: tab.id, url: tab.url, title: tab.title }
-  if (typeof favicon === "string") described.favicon = favicon
-  return described
-}
-
-async function currentTab(rawSession) {
-  try {
-    const { tabs } = await rawSession.tabList({ scope: "agent" })
-    return describeTab(tabs?.find((tab) => tab.active) ?? tabs?.[0])
-  } catch {
-    return undefined
-  }
-}
-
-function questionFor(variant, description) {
-  const options = [
-    { label: ALLOW, description: "Do it this once." },
-    { label: DECLINE, description: "Stop this action and tell the agent." },
-  ]
-  const question = `Allow the agent to ${description}?`
-  if (variant === "ask_user_question") {
-    return { waitForAnswer: true, questions: [{ header: QUESTION_HEADER, question, multiSelect: false, options }] }
-  }
-  return { wait_for_answer: true, questions: [{ id: "confirm_browser_action", header: QUESTION_HEADER, question, options }] }
-}
-
-function chosenAnswer(variant, details) {
-  if (details?.status !== "answered") return undefined
-  const entries = Object.values(details.answers ?? {})
-  if (entries.length !== 1) return undefined
-  return variant === "ask_user_question" ? entries[0] : entries[0]?.answers?.[0]
-}
+export const BROWSER_ENGINE_ENV = "OMO_BROWSER_ENGINE"
 
-async function confirmWithUser({ host, bridge, rawSession, description, action }) {
-  const decline = (unavailableReason) =>
-    unavailableReason === undefined
-      ? new BrowserActionDeclinedError(`The user declined: ${description}. Nothing was done; report that and do not retry it.`)
-      : new BrowserActionDeclinedError(`Nothing was done: ${description}. ${unavailableReason}`, "confirmation_unavailable")
-  let variant
-  try {
-    const names = host === undefined ? [] : await host.listTools()
-    variant = ["ask_user_question", "request_user_input"].find((name) => names.includes(name))
-  } catch {
-    variant = undefined
-  }
-  if (host === undefined || variant === undefined) {
-    throw decline("The user could not be asked because this session has no question tool.")
-  }
-  const tab = await currentTab(rawSession)
-  await bridge.emit("awaiting_confirmation", { action, tab })
-  let answer
-  try {
-    const result = await host.callTool(variant, questionFor(variant, description))
-    answer = result?.hasError === true ? undefined : chosenAnswer(variant, result?.details)
-  } catch {
-    answer = undefined
-  }
-  if (answer !== ALLOW) {
-    await bridge.emit("failed", { action, reason: "user_declined", tab })
-    throw decline()
-  }
+const TOOLKIT_TOOL = "omo_desktop_toolkit"
+const BUILTIN_UNAVAILABLE = {
+  unavailable: "this app does not offer its built-in browser to this session",
+  timeout: "the app did not answer the request for its built-in browser",
+  invalid_grant: "the app answered the request for its built-in browser with something unusable",
 }
 
-function hostOf(url) {
-  try {
-    return new URL(url).host
-  } catch {
-    return undefined
+export class BuiltinBrowserUnavailableError extends Error {
+  constructor(reason) {
+    const unavailable = Object.hasOwn(BUILTIN_UNAVAILABLE, reason)
+    super(
+      unavailable
+        ? `OmO's built-in browser is not available here: ${BUILTIN_UNAVAILABLE[reason]}. Every other browser works as usual: connectBrowserSkill() for the user's own browser, connectPipe() for a browser of your own.`
+        : `OmO's built-in browser was refused: ${reason === "user_stopped" ? "the user stopped browser work" : `the app refused it (${reason})`}. Stop browser work and report the refusal; do not open another browser.`,
+    )
+    this.name = "BuiltinBrowserUnavailableError"
+    this.code = "browser_builtin_unavailable"
+    this.reason = reason
   }
 }
 
-async function describeForConfirmation(rawSession, label, rawSessionTab) {
-  const site = hostOf(rawSessionTab?.url)
-  return site === undefined ? label : `${label} on ${site}`
-}
-
-function wrapSession(rawSession, context, bridge, host) {
-  const nowStopped = async () => {
-    if (!(await bridge.stopped())) return
-    try {
-      await rawSession.stop()
-    } catch {
-      // The daemon may already have ended the session.
-    }
-    throw new BrowserUserStoppedError()
-  }
-
-  const confirm = async (action, label) => {
-    const tab = await currentTab(rawSession)
-    await confirmWithUser({ host, bridge, rawSession, description: await describeForConfirmation(rawSession, label, tab), action })
-  }
+/**
+ * Inside OmO Desktop (`OMO_BROWSER_ENGINE` set) the library is the terminal's own, unchanged, plus
+ * `connectBuiltinBrowser()`: the app's built-in browser for this thread, the tab the user sees beside the chat.
+ */
+export function guardOmowright(raw, { env = process.env, host } = {}) {
+  const engine = env[BROWSER_ENGINE_ENV]
+  if (engine === undefined || engine === "") return raw
 
-  const readTarget = async (target) => {
-    const kind = targetKind(target)
-    if (kind.kind === "point") return { unknown: true, labels: [] }
+  const acquireBuiltinBrowser = async () => {
+    let details
     try {
-      if (kind.kind === "ref") {
-        const reply = await rawSession.getHtml({ ref: kind.ref, maxBytes: CLASSIFY_HTML_BYTES })
-        const html = String(reply?.html ?? "")
-        return { unknown: false, labels: labelsFromMarkup(html), editable: markupIsEditable(html) }
-      }
-      const reply = await rawSession.evaluate(describeElementExpression(kind.selector), { returnByValue: true, awaitPromise: false })
-      if (!reply || reply.ok === false) return { unknown: true, labels: [] }
-      if (reply.value === null || reply.value === undefined) return { unknown: false, labels: [], missing: true }
-      return { unknown: false, labels: labelsOf(reply.value), descriptor: reply.value }
+      details = (await host?.callTool(TOOLKIT_TOOL, { op: "acquire", toolkit: "browser" }))?.details
     } catch {
-      return { unknown: true, labels: [] }
-    }
-  }
-
-  const preflightClick = async (target) => {
-    const read = await readTarget(target)
-    if (read.unknown) return confirm("click", "click a control whose label could not be read")
-    const label = read.labels.find(isIrreversibleLabel)
-    if (label !== undefined) return confirm("click", `click "${label}"`)
-    return undefined
-  }
-
-  const preflightPress = async (key, options) => {
-    if (typeof key !== "string" || !ENTER_KEY.test(key)) return undefined
-    if (SENDING_CHORD.test(key)) return confirm("press", `press ${key}, which sends in many apps`)
-    if (/(^|\+)Shift\+/i.test(key)) return undefined
-    const sendsFromMessageBox = () => confirm("press", "press Enter in a message box, which sends in many apps")
-    const target = options?.target
-    if (target !== undefined && targetKind(target).kind !== "selector") {
-      const read = await readTarget(target)
-      if (read.unknown) return confirm("press", "press Enter on a control that could not be read")
-      if (read.editable) return sendsFromMessageBox()
-      const label = read.labels.find(isIrreversibleLabel)
-      return label === undefined ? undefined : confirm("press", `press Enter on "${label}"`)
+      details = undefined
     }
-    let described
+    if (details?.ok !== true) throw new BuiltinBrowserUnavailableError(typeof details?.reason === "string" ? details.reason : "unavailable")
+    // Without an endpoint CdpClient falls back to 127.0.0.1:9222 and would send the token to whatever listens there.
+    const endpoint = details.grant?.endpoint
+    if (typeof endpoint !== "string" || endpoint === "") throw new BuiltinBrowserUnavailableError("invalid_grant")
+    let token
     try {
-      const reply = await rawSession.evaluate(describeElementExpression(target === undefined ? undefined : targetKind(target).selector), {
-        returnByValue: true,
-        awaitPromise: false,
-      })
-      if (!reply || reply.ok === false) return confirm("press", "press Enter in a field that could not be read")
-      described = reply.value
+      token = (await readFile(details.grant.tokenFile, "utf8")).trim()
     } catch {
-      return confirm("press", "press Enter in a field that could not be read")
+      throw new BuiltinBrowserUnavailableError("invalid_grant")
     }
-    if (described === null || described === undefined) return undefined
-    const form = described.form
-    if (described.editable === true && (form === undefined || form.method !== "get")) return sendsFromMessageBox()
-    const own = labelsOf(described).find(isIrreversibleLabel)
-    if (own !== undefined && described.tag !== "input") return confirm("press", `press Enter on "${own}"`)
-    if (form === undefined) return undefined
-    const submit = (form.submitLabels ?? []).find(isIrreversibleLabel)
-    if (submit !== undefined) return confirm("press", `submit a form with "${submit}"`)
-    if (form.method === "post" && IRREVERSIBLE_ACTION_PATH.test(String(form.action))) return confirm("press", "submit a form that sends")
-    return undefined
-  }
-
-  const act = async (kind, run, { navigates = false, preflight } = {}) => {
-    await nowStopped()
-    if (preflight !== undefined) await preflight()
-    await bridge.emit("acting", { action: kind })
-    let result
-    try {
-      result = await run()
-    } catch (error) {
-      if (codeOf(error) === "user_aborted") {
-        await bridge.markStopped()
-        await bridge.emit("user_stopped", { action: kind })
-        try {
-          await rawSession.stop()
-        } catch {
-          // The daemon already ended it.
+    return { endpoint, authorization: `Bearer ${token}` }
+  }
+
+  // A CDP endpoint that shows only this thread's tabs. The token is read from the file the grant names, so it never
+  // passes through a tool result.
+  const connectBuiltinBrowser = async (options = {}) => {
+    let current = await acquireBuiltinBrowser()
+    // Concurrent refreshes share one acquire, so a token is never paired with another grant's endpoint.
+    let refreshing
+    const authorizer = {
+      async resolveAuthorization({ forceRefresh } = {}) {
+        if (forceRefresh) {
+          refreshing ??= acquireBuiltinBrowser()
+            .then((next) => {
+              current = next
+              client.cdpUrl = next.endpoint
+              return next
+            })
+            .finally(() => {
+              refreshing = undefined
+            })
+          return (await refreshing).authorization
         }
-        throw new BrowserUserStoppedError()
-      }
-      await bridge.emit("failed", { action: kind, reason: codeOf(error) })
-      throw error
-    }
-    if (navigates) await bridge.emit("navigated", { action: kind, tab: await currentTab(rawSession) })
-    await bridge.emit("idle", { action: kind })
-    return result
-  }
-
-  const plain = (method, navigates) => (...args) => act(method, () => rawSession[method](...args), { navigates })
-  const handlers = {
-    navigate: plain("navigate", true),
-    back: plain("back", true),
-    forward: plain("forward", true),
-    reload: plain("reload", true),
-    waitForNavigation: plain("waitForNavigation", true),
-    tabCreate: plain("tabCreate", true),
-    tabSelect: plain("tabSelect", true),
-    tabClose: plain("tabClose", true),
-    tabBorrow: plain("tabBorrow", true),
-    tabReturn: plain("tabReturn", true),
-    fill: plain("fill", false),
-    select: plain("select", false),
-    hover: plain("hover", false),
-    focus: plain("focus", false),
-    blur: plain("blur", false),
-    scrollTo: plain("scrollTo", false),
-    wheel: plain("wheel", false),
-    click: (target, options) => act("click", () => rawSession.click(target, options), { preflight: () => preflightClick(target) }),
-    press: (key, options) => act("press", () => rawSession.press(key, options), { preflight: () => preflightPress(key, options) }),
-    evaluate: (expression, options) =>
-      act("evaluate", () => rawSession.evaluate(expression, options), {
-        preflight: () => (scriptNeedsConfirmation(expression) ? confirm("evaluate", "run a script that can click, submit or send in your browser") : undefined),
-      }),
-    tool: async (name, params) => {
-      if (!READ_ONLY_RAW_TOOLS.has(name)) {
-        throw new BrowserEngineRefusal("browser_tool_blocked", `session.tool("${name}") skips the confirmation policy; only reads go through it. Call the matching session method instead.`)
-      }
-      return await rawSession.tool(name, params)
-    },
-    async stop() {
-      if (rawSession.stopped) return null
-      try {
-        return await rawSession.stop()
-      } finally {
-        await bridge.emit("stopped")
-      }
-    },
-  }
-
-  return new Proxy(rawSession, {
-    get(target, property) {
-      if (Object.hasOwn(handlers, property)) return handlers[property]
-      const value = Reflect.get(target, property, target)
-      return typeof value === "function" ? value.bind(target) : value
-    },
-  })
-}
-
-const GUARDED_SESSIONS = new WeakMap()
-
-function connectErrorFor(error) {
-  if (NOT_CONNECTED_CODES.has(codeOf(error))) {
-    return new BrowserNotConnectedError(
-      "Connect your browser: this session is set to drive the user's own browser, and none is connected. Ask the user to open the browser that has the BrowserSkill extension enabled, then try again. Do not use or launch another browser.",
-      { cause: error },
-    )
-  }
-  return error
-}
-
-export function guardOmowright(raw, { env = process.env, host } = {}) {
-  const engine = env[BROWSER_ENGINE_ENV]
-  if (engine === undefined || engine === "") return raw
-
-  const connectBrowserSkill = async (options) => {
-    if (!ENGINES.has(engine)) {
-      throw new BrowserEngineRefusal("browser_engine_unsupported", `${BROWSER_ENGINE_ENV} is "${engine}", which is not connected, builtin or none; browser use is refused.`)
-    }
-    if (engine === "none") {
-      throw new BrowserEngineRefusal("browser_engine_none", "Agent browser access is off for this project. Tell the user; do not try another browser.")
+        return current.authorization
+      },
     }
-    if (engine === "builtin") {
-      throw new BrowserEngineRefusal("browser_engine_builtin", "This session uses the app's built-in browser. Do not call connectBrowserSkill(); use the app's in-app browser tools.")
-    }
-    const context = { engine, sessionId: undefined }
-    const bridge = createBridge(host, context)
-    if (await bridge.stopped()) throw new BrowserUserStoppedError()
-    let rawSession
-    try {
-      rawSession = await raw.connectBrowserSkill(options)
-    } catch (error) {
-      await bridge.emit("connect_failed", { reason: codeOf(error) })
-      throw connectErrorFor(error)
-    }
-    context.sessionId = rawSession.sessionId
-    const session = wrapSession(rawSession, context, bridge, host)
-    GUARDED_SESSIONS.set(session, rawSession)
-    await bridge.emit("started")
-    return session
+    const client = new raw.CdpClient({ ...options.client, cdpUrl: current.endpoint, authorizer })
+    return await new raw.BrowserConnection(client, options).initialize()
   }
 
-  const bskSnapshot = (session, options) => raw.bskSnapshot(GUARDED_SESSIONS.get(session) ?? session, options)
-
-  return allowlistedLibrary(raw, engine, { connectBrowserSkill, bskSnapshot })
-}
-
-function ownedBrowserRefusal(engine) {
-  const why =
-    engine === "none"
-      ? "Agent browser access is off for this project."
-      : engine === "builtin"
-        ? "This session uses the app's built-in browser."
-        : engine === "connected"
-          ? "This session drives the user's own browser only."
-          : `${BROWSER_ENGINE_ENV} is "${engine}", which is not connected, builtin or none.`
-  const refusal = new BrowserEngineRefusal("browser_engine_owned_blocked", `${why} Do not launch an owned browser; tell the user instead.`)
-  refusal.engine = engine
-  return refusal
-}
-
-function blockedExport(name, engine) {
-  const blocked = function () {
-    const refusal = new BrowserEngineRefusal(
-      OWNED_SESSION_CREATORS.has(name) ? "browser_engine_owned_blocked" : "browser_engine_export_blocked",
-      OWNED_SESSION_CREATORS.has(name)
-        ? ownedBrowserRefusal(engine).message
-        : `omowright.${name} is not available while ${BROWSER_ENGINE_ENV} is set; it can act on a browser without the engine and confirmation policy.`,
-    )
-    refusal.engine = engine
-    if (new.target !== undefined) throw refusal
-    return Promise.reject(refusal)
-  }
-  Object.defineProperty(blocked, "name", { value: name })
-  return blocked
-}
-
-function allowlistedLibrary(raw, engine, guarded) {
-  const library = {}
-  for (const [name, value] of Object.entries(raw)) {
-    if (typeof value !== "function") library[name] = value
-    else if (PASSTHROUGH_FUNCTIONS.has(name)) library[name] = value
-    else library[name] = blockedExport(name, engine)
-  }
-  return Object.assign(library, guarded)
+  return { ...raw, connectBuiltinBrowser }
 }

package/packages/shared-skills/skills/browser/scripts/browser-install.mjs

@@ -36,7 +36,7 @@ if (json) {
   console.log(`attached engine ready: ${summary.browsersConnected.map((b) => `${b.name} ${b.version}`).join(", ")}`)
 } else {
   console.log(`cli: ${result.cli.installed ? `${result.cli.bskBin} (${result.cli.version})` : "install failed"}`)
-  console.log(`daemon: ${result.daemon.running ? "running" : `not running${result.daemon.error ? ` — ${result.daemon.error}` : ""}`}`)
+  console.log(`daemon: ${result.daemon.running ? "running" : `not running${result.daemon.error ? ` - ${result.daemon.error}` : ""}`}`)
   console.log(summary.browser ? `browser: ${summary.browser.label} [${summary.browser.id}] (${summary.browser.reason})` : `browser: not identified (${result.identification.reason})`)
   for (const r of summary.registrations) {
     console.log(`extension for ${r.browser}: ${r.registered ? (r.alreadyPresent ? "already registered" : "registered") : `not registered (${r.reason})`}`)

package/packages/shared-skills/skills/browser/scripts/omowright.mjs

@@ -3,16 +3,7 @@ import { dirname, join } from "node:path"
 import { fileURLToPath, pathToFileURL } from "node:url"
 import { guardOmowright } from "./browser-engine-guard.mjs"
 
-export {
-  BROWSER_CONFIRMATION_POLICY,
-  BROWSER_ENGINE_ENV,
-  BROWSER_STATE_EVENT,
-  BrowserActionDeclinedError,
-  BrowserEngineRefusal,
-  BrowserNotConnectedError,
-  BrowserUserStoppedError,
-  guardOmowright,
-} from "./browser-engine-guard.mjs"
+export { BROWSER_ENGINE_ENV, BuiltinBrowserUnavailableError, guardOmowright } from "./browser-engine-guard.mjs"
 
 const scriptDir = dirname(fileURLToPath(import.meta.url))
 const skillRoot = dirname(scriptDir)