lazycodex-ai 5.1.65 → 5.1.66

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

@@ -17,6 +17,38 @@ await session.stop()         // ALWAYS, on success and failure
 on purpose. Throws `BskRpcError` `no_browser_connected` when no extension is attached — that is a
 stop, not a cue to launch something else.
 
+## Shared control (BrowserSkill 0.4+)
+
+The person at the keyboard can work in the task tab while you do, so the extension refuses every
+gated page action with `permission_denied` / `data.reason: "cooperation_sync_required"` unless it
+carries the `context_id` of the latest `session.cooperate("sync")`. The daemon never fills it in
+for you.
+
+```js
+const sync = async () => (await session.cooperate("sync")).context_id
+await session.click("@e3", { context: await sync() })                 // one context, one action
+await session.fill("#q", "hello", { clearBefore: true, context: await sync() })
+```
+
+| Call | Use |
+|---|---|
+| `session.cooperate("sync", { tabId, maxTokens })` | returns `{ context_id, ... }`; pass it as `{ context }` to the next gated action, then sync again |
+| `session.cooperate("wait", { tabId, timeoutMs })` | after `cooperation_sync_required`: blocks (at most 25 s per call) until the person is done; repeat until it reports `ready`, then sync and replan from the live page |
+
+- **Gated** (need `{ context }`): `navigate` (except the first navigation of the untouched blank tab),
+  `back`, `forward`, `reload`, `click`, `hover`, `focus`, `blur`, `fill`, `press`, `select`,
+  `scrollTo`, `wheel`, `evaluate` (and so `bskSnapshot`), `tabClose`, `resize`, `emulate`,
+  `observe({ probeHover: true })`, `screenshot({ fullPage: true })`.
+- **Not gated:** `observe`, `snapshot`, `getHtml`, `screenshot()`, `console`, `network`,
+  `waitForNavigation`, the tab list/borrow/return calls, `requestHelp`.
+- `dependsOn: ["@e2", ...]` narrows the check to the observed regions your decision used.
+- A gated action accepts only its own options plus `{ context, dependsOn }`; any other key
+  (`contextId`, a stray option copied from another method) throws a `TypeError` before anything is
+  sent. Two exceptions: `bskSnapshot` and `screenshot({ fullPage: true })` pass unknown keys
+  through instead of throwing, so a misspelt `contextId` there sends no context and the daemon
+  refuses the call with `cooperation_sync_required`.
+- Never replay a refused action blindly: the page may have changed under the person's hands.
+
 ## Targets
 
 | Form | Meaning |
@@ -30,12 +62,12 @@ stop, not a cue to launch something else.
 
 | Call | Returns |
 |---|---|
-| `bskSnapshot(session, { interactive, maxDepth })` | `{ tree, refs, css }` — the OmOWright accessibility tree with refs, computed in the page **without** leaving a global or touching the DOM |
+| `bskSnapshot(session, { interactive, maxDepth, context })` | `{ tree, refs, css }` — the OmOWright accessibility tree with refs, computed in the page **without** leaving a global or touching the DOM |
 | `session.observe({ maxTokens, cursor, probeHover })` | the daemon's semantic tree (`@vom`) with `@eN` refs, layers and hover probes — **the default read for shadow DOM and iframes** |
 | `session.snapshot({ maxDepth, maxTokens })` | the daemon's plain accessibility tree |
 | `session.getHtml({ ref, maxBytes })` | exact markup |
 | `session.screenshot({ ref })` / `screenshot({ fullPage: true })` | `{ buffer, width, height, captureId }`; full-page captures stream back in chunks |
-| `session.evaluate(expression, { awaitPromise, timeoutMs })` | `{ ok, value, error }` — **check `.ok`**; a resolved promise does not mean the script succeeded |
+| `session.evaluate(expression, { awaitPromise, timeoutMs, context })` | `{ ok, value, error }` — **check `.ok`**; a resolved promise does not mean the script succeeded |
 | `session.console({ since })` / `session.network({ since })` | buffered console entries / request metadata (no bodies) |
 
 **Refs are reissued by every read.** Read a ref and act on it in the same cycle. A ref captured
@@ -44,6 +76,10 @@ neighbouring row.
 
 ## Acting
 
+Every call here is gated: add `context` (from `cooperate("sync")`) to its options object, as in
+`session.click(target, { context })`, `session.resize(width, height, { context })`,
+`session.tabClose(id, { context })`.
+
 | Need | Call |
 |---|---|
 | Click | `session.click(target, { button, clickCount, modifiers })` |
@@ -75,7 +111,7 @@ Traps:
 const { tabs } = await session.tabList({ scope: "user" })   // "user" | "agent" | "all"
 await session.tabBorrow(tabId)                                // the user confirms in the browser (60 s)
 await session.tabReturn(tabId)                                // stop() returns anything still borrowed
-await session.tabCreate({ url }); await session.tabSelect(id); await session.tabClose(id)
+await session.tabCreate({ url }); await session.tabSelect(id); await session.tabClose(id, { context: await sync() })
 ```
 
 Never invent tab ids and never repeat a denied borrow.
@@ -96,7 +132,8 @@ Every refusal is a `BskRpcError` with the daemon's own `code`:
 | `no_browser_connected` | no extension attached | run the onboarding script, relay the human step, wait |
 | `not_found` | stale ref or unknown session | read again; if the session is gone, start a new one |
 | `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 |
+| `permission_denied` with `data.reason: "cooperation_sync_required"` | a gated action without the latest sync context, or the person is using the tab | `cooperate("wait")` until `ready`, sync, read the page again, replan |
+| `permission_denied` (any other reason) | `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 |
 | `cdp_failed` | the page cannot be attached (restricted URL, DevTools open) | say which page and why |

package/packages/shared-skills/skills/browser/references/owned-engine/frames-and-humans.md

@@ -19,10 +19,21 @@ miss has another cause and you climb the ladder instead.
 
 ## Dialogs never block
 
-`alert`, `confirm`, `prompt`, and `beforeunload` are answered by the `dialogPolicy` passed to
-`connectPipe` (or `browser.setDialogPolicy`), at the protocol layer, before the page sees them.
-Default to accepting (`{ accept: true }`; a function receives `{ type, message }` and returns
-`{ accept, promptText }`). `page.on("dialog")` still fires for observability. A run that hangs on
+`alert`, `confirm`, `prompt`, and `beforeunload` are answered at the protocol layer, before the
+page sees them: by a `dialog` listener that answers, otherwise by the `dialogPolicy` passed to
+`connectPipe` (or `browser.setDialogPolicy`). Default to accepting (`{ accept: true }`; a policy
+function receives a plain `{ type, message, defaultPrompt, url }` and returns `{ accept, promptText }`).
+
+`page.on("dialog", (dialog) => ...)` hands each listener a Playwright-style `Dialog` object, not a
+plain object: read it through methods (`dialog.type()`, `dialog.message()`, `dialog.defaultValue()`,
+and the `dialog.url` getter). A listener can answer it itself, which replaces the policy for that
+dialog; a listener that only observes leaves it to the policy:
+
+```js
+page.on("dialog", (dialog) => dialog.type() === "prompt" ? dialog.accept("42") : dialog.dismiss())
+```
+
+A dialog is answered once; a second `accept()` / `dismiss()` throws. A run that hangs on
 an unhandled dialog looks exactly like a hang with no cause, which is the most expensive kind to
 diagnose.
 

package/packages/shared-skills/skills/browser/references/recipes/1password.md

@@ -28,13 +28,15 @@ await session.tabReturn(vault.tab_id)
 
 The app mutates its URL hash without updating the document title, so a signed-in vault can still
 report a sign-in title. A live session's `location.href` contains the app path and never the
-sign-in path. Read the URL from `tabList`, or `session.evaluate("location.href")`.
+sign-in path. Read the URL from `tabList`, or `session.evaluate("location.href", { context })` with a
+fresh `context` from `session.cooperate("sync")` (see the shared-control section of
+[../commands.md](../commands.md)).
 
 ## The browser may be shared
 
 Other automation may be driving the same window.
 
-- **Clear the search box before typing** (`fill(target, value, { clearBefore: true })`). It often
+- **Clear the search box before typing** (`fill(target, value, { clearBefore: true, context })`). It often
   holds someone else's query, and typing alone appends to it, returning confident results for the
   wrong search.
 - **Read the autocomplete listbox, not the results grid.** The grid holds whatever query was last

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

@@ -5,5 +5,5 @@
     "index.js": "f026b391aead15d15f361e82861336c023c80c42b01fc0ba28f6d5d77a16acc8",
     "page-bundle.js": "ca93c410e45469db3f22951d953e32444975daf8827ff10a877c537338c8feb0"
   },
-  "stagedAtUtc": "2026-11-09T00:16:05.821Z"
+  "stagedAtUtc": "2026-11-10T05:28:43.197Z"
 }

package/packages/shared-skills/skills/debugging/references/tools/browser-qa.md

@@ -62,10 +62,11 @@ When the bug only happens signed in:
 
 ```js
 const session = await omowright.connectBrowserSkill({ name: "debug repro", focused: false })
+const sync = async () => (await session.cooperate("sync")).context_id   // BrowserSkill 0.4: one context per page action
 try {
-  await session.navigate(url)
-  const { tree, css } = await omowright.bskSnapshot(session, { interactive: true })
-  await session.click({ selector: css.e7 })
+  await session.navigate(url, { context: await sync() })
+  const { tree, css } = await omowright.bskSnapshot(session, { interactive: true, context: await sync() })
+  await session.click({ selector: css.e7 }, { context: await sync() })
   const errors = await session.console({ since: 0 })
   const shot = await session.screenshot()
 } finally {

package/packages/shared-skills/skills/ultimate-browsing/SKILL.md

@@ -111,7 +111,7 @@ The rest of the surface (CUA coordinates, captcha solving, routes, traces, frame
 
 ### Tier 2b — attached engine (the user's account on a blocked host)
 
-When the blocked flow 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.
+When the blocked flow 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()`, each page action carrying `{ context }` from a fresh `session.cooperate("sync")` (BrowserSkill 0.4 refuses it otherwise). 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)
 

package/packages/shared-skills/skills/ulw-research/SKILL.md

@@ -29,7 +29,7 @@ When translating `load_skills=[...]`, include the requested skill names in the s
 
 # ULW-RESEARCH — Maximum-Saturation Research
 
-You are the research orchestrator. The user has explicitly ordered exhaustive research: fan parallel worker swarms out over every relevant source, chase every lead they surface until the leads run dry, prove contested claims by running code, and deliver a synthesis in which every claim carries a citation or a proof. Exhaustive coverage is the assignment, not a risk to manage.
+You are the research orchestrator. The user has explicitly ordered exhaustive research: fan parallel worker swarms out over every relevant source, chase every lead they surface until the leads run dry, prove every conclusion by probing a source, reading the file, or running a tool before asserting it, and deliver a synthesis in which every claim carries a citation or a proof. Exhaustive coverage is the assignment, not a risk to manage.
 
 ## Activation
 
@@ -51,7 +51,7 @@ The research is done when all of these hold:
 
 - Every axis from Phase 0 was covered by at least one dedicated worker.
 - Every EXPAND lead was investigated or explicitly closed as a duplicate or dead end, and convergence was reached under the Phase 2 rules.
-- Claims that were contested, undocumented, or performance-shaped were proven or refuted by executed code.
+- Data came first: every conclusion was proven by probing a source, reading the file, or running a tool before it was asserted, never by plausibility, recall, or the shape of the code; contested, undocumented, and performance-shaped claims were additionally proven or refuted by executed code.
 - Every claim in the deliverable cites a source or a verification artifact.
 - Every asserted claim is represented in the claim graph, tied to an intent-vs-reality diff when an expected truth exists, and backed by observation manifest entries from independent observation groups or a documented single-source exception; convergence or exception status is explicit.
 - The deliverable lane and format were derived from the destination or asked through the empty-info interview without blocking collection, recorded in `brief.md` with `answered_by`, and the final materials match that record.
@@ -72,7 +72,7 @@ Saturation is not just more searching; it is a knowledge-production protocol. Th
 - `verification-economics.md` — one row per proof decision. Required fields: claim, risk, error cost, verification cost/time, chosen verification path, defer/verify decision, outcome, and residual risk.
 - `cause-disappearance.md` — one row per causal finding. Required fields: cause id, expected truth, previous observation, `last_seen`, disconfirming observation, replacement cause if any, current status, and whether the violation is no longer observed.
 
-Observation candidates and claim candidates travel back from workers as message text. The orchestrator writes the instrumentation artifacts, links candidates into the intent diff and claim graph, and records where each observation entered the synthesis. A conclusion is not ready for final materials until its expected truth/reality diff is closed or marked unknown, its claim node exists, and its independent-observation convergence status is supported or explicitly excepted.
+Observation candidates and claim candidates travel back from workers as message text. **Every conclusion stands on an observation a tool produced** — a page read, a file read, a command run — recorded in `observation-manifest.md`: a claim candidate, a DEAD END, a convergence call, and your own judgment that a topic is settled alike. What you or a worker knows from memory is a LEAD to probe, never evidence. The orchestrator writes the instrumentation artifacts, links candidates into the intent diff and claim graph, and records where each observation entered the synthesis. A claim is not ready for final materials until its expected truth/reality diff is closed or marked unknown, its claim node exists, and its independent-observation convergence status is supported or explicitly excepted.
 
 ## Run the swarm as a cooperating team
 
@@ -105,15 +105,15 @@ Every research spawn message contains, in order:
 2. The budget lift: "This is an explicit exhaustive-research assignment. Your default retrieval budget and stop-when-answered rules do not apply — run the full protocol below and report every lead."
 3. Scope — the axis, the sources to hit, and what a complete answer contains.
 4. The role protocol (Phase 1).
-5. The reply tail. EXPAND markers, observation candidates, and claim candidates travel back as message text, never as files. Every worker ends the reply with:
+5. The reply tail. EXPAND markers, observation candidates, and claim candidates travel back as message text, never as files. Each claim candidate carries `OBSERVED: <URL read | file:line | command and its output>`; a claim the worker only remembers goes into the tail as a LEAD. Every worker ends the reply with:
 
 ```
 ## EXPAND
 - LEAD: <discovery not yet investigated> — WHY: <why it matters> — ANGLE: <suggested search>
-- DEAD END: <lead explored to exhaustion>
+- DEAD END: <lead explored to exhaustion> — PROBED: <the searches, reads, or commands that exhausted it>
 ```
 
-A worker with nothing to expand writes `## EXPAND` followed by `none — <one-line reason>`. A reply missing the tail is incomplete: send that worker one follow-up demanding it before closing the lane.
+A worker with nothing to expand writes `## EXPAND` followed by `none — <one-line reason>`. A reply missing the tail, or a claim or DEAD END missing its `OBSERVED:`/`PROBED:` line, is incomplete: send that worker one follow-up demanding it before closing the lane.
 
 ## Execution references
 

package/packages/shared-skills/skills/ulw-research/references/research-collection.md

@@ -139,7 +139,7 @@ task(subagent_type="explore", run_in_background=true, prompt="TASK: act as a cod
 This is an explicit exhaustive-research assignment. Your default retrieval budget and stop-when-answered rules do not apply — run the full protocol below and report every lead.
 SCOPE: find everything in this codebase related to <angle>: <what complete looks like>.
 PROTOCOL: grep 3+ keyword variations; structural search; LSP references; globs; git history (-S and --grep). Cross-validate across tools. Report absolute paths and file:line patterns.
-End your reply with the ## EXPAND tail: '- LEAD: <discovery> — WHY: <why> — ANGLE: <search>' per lead, or 'none — <reason>'.")
+Tag every claim OBSERVED: <URL | file:line | command>. End your reply with the ## EXPAND tail: '- LEAD: <discovery> — WHY: <why> — ANGLE: <search>' per lead, '- DEAD END: <lead> — PROBED: <what exhausted it>', or 'none — <reason>'.")
 ```
 
 ## Phase 2 — Expand until convergence
@@ -154,7 +154,7 @@ This loop is what makes the mode research rather than search. Collect returns as
 task(category="deep-low", load_skills=["browser"], run_in_background=true, prompt="TASK: expansion wave <N> — investigate: <lead>.
 PARENT: <which return surfaced it>. This is an explicit exhaustive-research assignment; budgets do not apply.
 <role protocol for the lead's territory — web protocol for external leads, explore protocol for codebase leads>
-End your reply with the ## EXPAND tail.")
+Tag every claim OBSERVED: <URL | file:line | command>. End your reply with the ## EXPAND tail.")
 ```
 
 ### Excursions — dive deep on a new find, then surface back out

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

@@ -65,14 +65,15 @@ cloning its profile:
 
 ```js
 const session = await omowright.connectBrowserSkill({ name: "visual-qa capture", focused: false })
+const sync = async () => (await session.cooperate("sync")).context_id   // BrowserSkill 0.4: one context per page action
 try {
-  await session.navigate(url, { waitUntil: "load" })
-  await session.resize(1440, 900)                                 // desktop column of the matrix
+  await session.navigate(url, { waitUntil: "load", context: await sync() })
+  await session.resize(1440, 900, { context: await sync() })     // desktop column of the matrix
   await Bun.write(`${outDir}/${route}-1440-top.png`, (await session.screenshot()).buffer)   // { buffer, width, height }
-  await session.emulate({ overrides: { width: 390, mobile: true } })  // phone column; `off: true` restores
+  await session.emulate({ overrides: { width: 390, mobile: true }, context: await sync() })  // phone column; `off: true` restores
   await Bun.write(`${outDir}/${route}-390-top.png`, (await session.screenshot()).buffer)
 } finally {
-  await session.emulate({ off: true })
+  await session.emulate({ off: true, context: await sync() })
   await session.stop()
 }
 ```