lazycodex-ai 5.1.64 → 5.1.66

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

@@ -0,0 +1,68 @@
+// The browser doctor's report: one bskDoctor run turned into the `state` the browser skill routes on, its remedy, and a
+// summary. browser-doctor.mjs is the CLI over it; `doctorOptions` reach bskDoctor unchanged (the CLI passes none).
+
+// BrowserSkill extension 0.4.0 put every task tab into a native "BrowserSkill" tab group that the browser saves and
+// syncs, so each task left a group in the user's own browser (upstream removed the grouping in 0.4.1).
+const TAB_GROUPING_EXTENSION_VERSION = "0.4.0"
+
+function stateOf(report, outdated) {
+  if (report.browsersConnected.length > outdated.length) return "ready"
+  if (outdated.length > 0) return "outdated-extension"
+  if (!report.cli.installed) return "no-cli"
+  if (!report.daemon.running) return "no-daemon"
+  if (report.browsers.length === 0 && !report.primary) return "no-browser-support"
+  return report.identification.needsChoice ? "choose-browser" : "no-extension"
+}
+
+const named = (browsers) => browsers.map((browser) => `${browser.browser_name} [${browser.instance_id}]`).join(", ")
+
+// With a 0.4.0 browser connected beside an up-to-date one, a session started without `browser` may land on the 0.4.0
+// one (the daemon picks), so the remedy names the up-to-date browser's instance and lists the browsers to avoid.
+function readyRemedy(report, outdated) {
+  const live = "Attached engine is live: const { connectBrowserSkill } = await import(omowrightEntry); "
+  if (outdated.length === 0) return `${live}const session = await connectBrowserSkill({ name: "<task>", focused: false })`
+  const usable = report.browsersConnected.filter((connected) => !outdated.includes(connected))
+  const others = usable.length > 1 ? ` (or another up-to-date browser: ${named(usable.slice(1))})` : ""
+  return `${live}const session = await connectBrowserSkill({ name: "<task>", focused: false, browser: "${usable[0].instance_id}" })${others}. Always pass browser: the BrowserSkill extension in ${named(outdated)} is 0.4.0, which leaves a "BrowserSkill" tab group in the user's browser after every task; never start a session there, and ask the user to update it to 0.4.1 or later and delete any saved "BrowserSkill" tab groups by hand.`
+}
+
+function remedyFor(state, report, outdated) {
+  switch (state) {
+    case "ready":
+      return readyRemedy(report, outdated)
+    case "outdated-extension":
+      return `The connected BrowserSkill extension is 0.4.0 (${named(outdated)}), which leaves a "BrowserSkill" tab group in the user's browser after every task. Do not start a session. Ask the user to update the extension to 0.4.1 or later (chrome://extensions, Developer mode, Update) and to delete any saved "BrowserSkill" tab groups by hand, then re-run this doctor.`
+    case "no-cli":
+      return "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."
+    case "no-daemon":
+      return "Run node \"<skill-root>/scripts/browser-install.mjs\" (it starts the daemon through `bsk status`), then re-run this doctor."
+    case "no-extension":
+      return report.nextStep ?? "Register the extension with browser-install.mjs, then relay its human step to the user and re-run this doctor."
+    case "choose-browser":
+      return `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>.`
+    case "no-browser-support":
+      return "No Chromium-family browser profile was found on this machine. Say so and stop; do not substitute another engine."
+  }
+}
+
+/** @param {{ omowright: any, entry: string | undefined, browser?: string, doctorOptions?: Record<string, unknown> }} options */
+export async function runBrowserDoctor({ omowright, entry, browser, doctorOptions = {} }) {
+  const report = await omowright.bskDoctor({ waitForBrowserMs: 0, browser, ...doctorOptions })
+  const outdated = report.browsersConnected.filter((connected) => connected.extension_version === TAB_GROUPING_EXTENSION_VERSION)
+  const state = stateOf(report, outdated)
+  return {
+    state,
+    omowright: entry,
+    cli: report.cli,
+    daemon: { running: report.daemon.running, version: report.daemon.version ?? null, protocolVersion: report.daemon.protocolVersion ?? null, error: report.daemon.error ?? null },
+    browser: report.primary ? { id: report.primary.id, label: report.primary.label, confidence: report.identification.confidence, reason: report.identification.reason } : null,
+    identificationReason: report.identification.reason,
+    candidates: report.identification.candidates.map((c) => ({ id: c.id, label: c.label, signals: c.signals })),
+    defaultBrowser: report.identification.defaultBrowser,
+    registeredElsewhere: report.identification.registeredElsewhere,
+    browsersDetected: report.browsers.map((detected) => ({ id: detected.id, userDataDir: detected.userDataDir, extensionRegistered: detected.extensionRegistered })),
+    browsersConnected: report.browsersConnected.map((connected) => ({ instanceId: connected.instance_id, name: connected.browser_name, version: connected.browser_version, extensionVersion: connected.extension_version ?? null })),
+    nextStep: report.nextStep,
+    remedy: remedyFor(state, report, outdated),
+  }
+}

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

@@ -1,57 +1,22 @@
 #!/usr/bin/env node
+import { runBrowserDoctor } from "./browser-doctor-report.mjs"
 import { loadOmowright } from "./omowright.mjs"
 
 const { entry, omowright } = await loadOmowright()
 const browserArg = process.argv.find((arg) => arg.startsWith("--browser="))
-const report = await omowright.bskDoctor({ waitForBrowserMs: 0, browser: browserArg ? browserArg.slice("--browser=".length) : undefined })
-
-const state = report.ready
-  ? "ready"
-  : !report.cli.installed
-    ? "no-cli"
-    : !report.daemon.running
-      ? "no-daemon"
-      : report.browsers.length === 0 && !report.primary
-        ? "no-browser-support"
-        : report.identification.needsChoice
-          ? "choose-browser"
-          : "no-extension"
-
-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-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>.`,
-  "no-browser-support": "No Chromium-family browser profile was found on this machine. Say so and stop; do not substitute another engine.",
-}
-
-const summary = {
-  state,
-  omowright: entry,
-  cli: report.cli,
-  daemon: { running: report.daemon.running, version: report.daemon.version ?? null, protocolVersion: report.daemon.protocolVersion ?? null, error: report.daemon.error ?? null },
-  browser: report.primary ? { id: report.primary.id, label: report.primary.label, confidence: report.identification.confidence, reason: report.identification.reason } : null,
-  candidates: report.identification.candidates.map((c) => ({ id: c.id, label: c.label, signals: c.signals })),
-  defaultBrowser: report.identification.defaultBrowser,
-  registeredElsewhere: report.identification.registeredElsewhere,
-  browsersDetected: report.browsers.map((browser) => ({ id: browser.id, userDataDir: browser.userDataDir, extensionRegistered: browser.extensionRegistered })),
-  browsersConnected: report.browsersConnected.map((browser) => ({ instanceId: browser.instance_id, name: browser.browser_name, version: browser.browser_version })),
-  nextStep: report.nextStep,
-  remedy: REMEDIES[state],
-}
+const { identificationReason, ...summary } = await runBrowserDoctor({ omowright, entry, browser: browserArg ? browserArg.slice("--browser=".length) : undefined })
 
 if (process.argv.includes("--json")) {
   console.log(JSON.stringify(summary, null, 2))
 } else {
-  console.log(`state: ${state}`)
+  console.log(`state: ${summary.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(`browser the user uses: ${summary.browser ? `${summary.browser.label} [${summary.browser.id}] (${summary.browser.reason})` : `not identified (${report.identification.reason})`}`)
+  console.log(`cli: ${summary.cli.installed ? `${summary.cli.bskBin} (${summary.cli.version})` : "not installed"}`)
+  console.log(`daemon: ${summary.daemon.running ? `running (${summary.daemon.version}, protocol ${summary.daemon.protocolVersion})` : `not running${summary.daemon.error ? ` - ${summary.daemon.error}` : ""}`}`)
+  console.log(`browser the user uses: ${summary.browser ? `${summary.browser.label} [${summary.browser.id}] (${summary.browser.reason})` : `not identified (${identificationReason})`}`)
   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)`)
   console.log(`browsers detected: ${summary.browsersDetected.map((b) => `${b.id}${b.extensionRegistered ? " (extension registered)" : ""}`).join(", ") || "none"}`)
-  console.log(`browsers connected: ${summary.browsersConnected.map((b) => `${b.name} ${b.version} [${b.instanceId}]`).join(", ") || "none"}`)
-  console.log(`\n${REMEDIES[state]}`)
+  console.log(`browsers connected: ${summary.browsersConnected.map((b) => `${b.name} ${b.version} [${b.instanceId}]${b.extensionVersion ? ` extension ${b.extensionVersion}` : ""}`).join(", ") || "none"}`)
+  console.log(`\n${summary.remedy}`)
 }

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

@@ -9,10 +9,16 @@ const scriptDir = dirname(fileURLToPath(import.meta.url))
 const skillRoot = dirname(scriptDir)
 
 export function resolveOmowrightEntry(env = process.env) {
+  const packageRoot = join(skillRoot, "..", "..", "..", "..", "node_modules", "omowright")
+  // Same order as stage-omowright-runtime.mjs: sources before the build, `.ts` before `.js`. A git
+  // install carries the sources (TypeScript since omowright's strict port, which only Bun imports);
+  // a package built for its `exports` carries `dist/` only.
   const candidates = [
     env.OMOWRIGHT_ROOT ? join(env.OMOWRIGHT_ROOT, "index.js") : undefined,
     join(skillRoot, "runtime", "omowright", "index.js"),
-    join(skillRoot, "..", "..", "..", "..", "node_modules", "omowright", "src", "index.js"),
+    join(packageRoot, "src", "index.ts"),
+    join(packageRoot, "src", "index.js"),
+    join(packageRoot, "dist", "index.js"),
   ].filter((candidate) => candidate !== undefined)
   return candidates.find((candidate) => existsSync(candidate))
 }

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()
 }
 ```