lazycodex-ai 5.1.64 → 5.1.66

package/packages/omo-codex/plugin/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/omo-codex/plugin/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/omo-codex/plugin/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/omo-codex/plugin/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/omo-codex/plugin/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/omo-codex/plugin/skills/ulw-research/SKILL.md

@@ -31,7 +31,7 @@ For work likely to exceed one wait cycle, require the child to send `WORKING: <t
 
 # 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
 
@@ -53,7 +53,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.
@@ -74,7 +74,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
 
@@ -107,15 +107,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/omo-codex/plugin/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/omo-codex/plugin/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()
 }
 ```

package/packages/omo-codex/scripts/install-dist/install-local.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// omo-codex-install:a9613ef38f6cb8eadfc32b34f2bbd2b217fc2f498913b81fd64c05ce3c262f32:8902ae37787a3b65b0e739f68d86961b85d6cdfb63ffa66dd8d93cb78c67e6d9
+// omo-codex-install:cdd45658775781f93e20bd61c5320b34ed32c29a81a96a0d4ab528d74c807dda:e41af6deb14deb208e4ed49aa5a5d5db7b4ffe13ae40a534d73753f5970b2a58
 var __esm = (fn, res, err) => () => {
   if (fn)
     try {
@@ -10205,7 +10205,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@oh-my-opencode/omo-codex",
-    version: "5.1.64",
+    version: "5.1.66",
     type: "module",
     private: true,
     description: "Codex harness adapter for oh-my-openagent. Vendored Codex plugin namespace (omo) + TypeScript installer + telemetry.",
@@ -19902,6 +19902,22 @@ var OmoMemoryProjectionLayerSchema = object({
   max_entries_per_directory: number2().int().min(0).optional(),
   max_bytes: number2().int().min(0).optional()
 }).strict();
+var OmoMemoryRuntimeSchema = object({
+  retention_days: number2().int().min(1).default(7),
+  abandoned_journal_days: number2().int().min(1).default(14),
+  completions_days: number2().int().min(1).default(30),
+  pass_budget_ms: number2().int().min(1).default(60000),
+  discard_unreflected_journals: boolean2().default(false),
+  max_bytes: number2().int().min(0).default(2 * 1024 * 1024 * 1024)
+}).strict();
+var OmoMemoryRuntimeLayerSchema = object({
+  retention_days: number2().int().min(1).optional(),
+  abandoned_journal_days: number2().int().min(1).optional(),
+  completions_days: number2().int().min(1).optional(),
+  pass_budget_ms: number2().int().min(1).optional(),
+  discard_unreflected_journals: boolean2().optional(),
+  max_bytes: number2().int().min(0).optional()
+}).strict();
 var OmoMemoryAgentOverridesSchema = object({
   enabled: boolean2().optional(),
   agent: string2().min(1).optional(),
@@ -19917,6 +19933,7 @@ var OmoMemoryAgentOverridesSchema = object({
   search: OmoMemorySearchLayerSchema.optional(),
   recall: OmoMemoryRecallLayerSchema.optional(),
   projection: OmoMemoryProjectionLayerSchema.optional(),
+  runtime: OmoMemoryRuntimeLayerSchema.optional(),
   compile_warn_tokens: number2().int().positive().optional()
 }).strict();
 var OmoMemoryAutoIdentitySchema = _enum(["path", "git"]);
@@ -19961,6 +19978,7 @@ var OmoMemorySettingsSchema = object({
   }),
   project_scope: OmoMemoryProjectScopeSchema.default({ nudge: true, recall: true }),
   projection: OmoMemoryProjectionSchema.default({ max_entries_per_directory: 0, max_bytes: 40960 }),
+  runtime: OmoMemoryRuntimeSchema.default({ retention_days: 7, abandoned_journal_days: 14, completions_days: 30, pass_budget_ms: 60000, discard_unreflected_journals: false, max_bytes: 2 * 1024 * 1024 * 1024 }),
   compile_warn_tokens: number2().int().positive().default(30000),
   agents: record(string2(), OmoMemoryAgentOverridesSchema).default({})
 }).strict();
@@ -19981,6 +19999,7 @@ var OmoMemorySettingsLayerSchema = object({
   recall: OmoMemoryRecallLayerSchema.optional(),
   project_scope: OmoMemoryProjectScopeLayerSchema.optional(),
   projection: OmoMemoryProjectionLayerSchema.optional(),
+  runtime: OmoMemoryRuntimeLayerSchema.optional(),
   compile_warn_tokens: number2().int().positive().optional(),
   agents: record(string2(), OmoMemoryAgentOverridesSchema).optional()
 }).strict();

package/packages/shared-skills/skills/browser/SKILL.md

@@ -14,7 +14,8 @@ One library, two engines. omowright ships inside this skill; choose the engine b
 | A 403/WAF host the attached engine cannot open, a platform with a native reader, an archive snapshot | neither | the `ultimate-browsing` skill |
 
 **Attached is the default,** because it is the only engine carrying the user's logins and the only
-one where a human is a single call away. Never substitute one engine for the other silently: if
+one where a human is a single call away. It works in an Agent Window inside the user's own browser profile, never in
+a copy of that profile, and exists only where the user installed and enabled the BrowserSkill extension. Never substitute one engine for the other silently: if
 the attached engine is not set up, run the onboarding script and tell the user its one remaining
 step.
 
@@ -58,6 +59,7 @@ node "<skill-root>/scripts/browser-doctor.mjs" --json
 | `no-cli` / `no-daemon` / `no-extension` | something is missing | `node "<skill-root>/scripts/browser-install.mjs" [--browser=<id>]` prepares everything it can for **the browser the user uses**, then prints the **single** step only the user can do (relaunch that browser and click **Enable**); relay it verbatim, wait, re-run the doctor |
 | `choose-browser` | the signals do not single out one browser (Safari/Firefox default, an idle default while another browser runs, several in use) | nothing was installed; take the browser from memory or ask the user, then `browser-install.mjs --browser=<id>` |
 | `no-browser-support` | no Chromium-family profile on this machine | say so and stop |
+| `outdated-extension` | the only connected extension is BrowserSkill 0.4.0, which leaves a "BrowserSkill" tab group in the user's browser after every task | start no session; relay the doctor's remedy (update the extension to 0.4.1 or later, delete saved "BrowserSkill" groups by hand), then re-run the doctor |
 
 **Install into the browser the user actually uses, never into whatever happens to be on disk.** Before
 installing, check your memory for the user's browser; otherwise read the doctor's `browser` (picked
@@ -73,14 +75,15 @@ you hit and ask.
 
 ```js
 const session = await omowright.connectBrowserSkill({ name: "<task>", focused: false })
+const sync = async () => (await session.cooperate("sync")).context_id                      // one context per page action
 try {
-  await session.navigate("https://example.com/", { waitUntil: "load" })
-  const { tree, refs, css } = await omowright.bskSnapshot(session, { interactive: true })  // OmOWright tree + refs, no trace in the page
-  await session.click({ selector: css.e3 })                                                 // css[ref] is null inside shadow roots:
+  await session.navigate("https://example.com/", { waitUntil: "load", context: await sync() })
+  const { tree, refs, css } = await omowright.bskSnapshot(session, { interactive: true, context: await sync() })  // OmOWright tree + refs, no trace in the page
+  await session.click({ selector: css.e3 }, { context: await sync() })                      // css[ref] is null inside shadow roots:
   const vom = await session.observe({ maxTokens: 4000 })                                    //   then read the daemon's own tree ...
-  await session.click("@e7")                                                                //   ... and click its @eN ref
-  await session.fill(css.e5, "hello")
-  await session.press("Enter")
+  await session.click("@e7", { context: await sync() })                                     //   ... and click its @eN ref
+  await session.fill(css.e5, "hello", { context: await sync() })
+  await session.press("Enter", { context: await sync() })
   await session.waitForNavigation({ waitUntil: "load" })
   const shot = await session.screenshot()                                                   // { buffer, width, height, captureId }
 } finally {
@@ -95,6 +98,20 @@ try {
 4. **Borrow a user tab explicitly** (`tabList({ scope: "user" })`, `tabBorrow(id)`, `tabReturn(id)`).
    Borrowing prompts the user; never invent tab ids and never repeat a denied borrow.
 5. **Always `stop()` the session,** on success and on failure.
+6. **Sync before every page action.** The person at the keyboard can work in the same tab, so
+   BrowserSkill 0.4 refuses an action (`permission_denied`, `data.reason: "cooperation_sync_required"`)
+   unless it carries `{ context }` from the latest `session.cooperate("sync")`. A context is good
+   for one action: sync, act with `{ context }`, sync again. Navigation, every input method,
+   `evaluate` (and so `bskSnapshot`), `tabClose`, `resize`, `emulate`, `observe({ probeHover })` and
+   `screenshot({ fullPage: true })` need it; plain reads (`observe`, `snapshot`, `getHtml`,
+   `screenshot()`, `console`, `network`, `waitForNavigation`) do not.
+7. **On `cooperation_sync_required`, wait for the person, then replan.** Call
+   `session.cooperate("wait", { timeoutMs: 25_000 })` until it reports `ready`, read the page again
+   and decide afresh; never replay the refused action blindly.
+8. **Pass only the options a method takes.** A gated action throws a `TypeError` on any other key
+   (a misspelt `contextId` would otherwise send no context). `bskSnapshot` and
+   `screenshot({ fullPage: true })` do not throw: they drop the stray key, and the daemon then
+   refuses the call with `cooperation_sync_required`.
 
 Every method, its options, and the failure codes are in [references/commands.md](references/commands.md).
 

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