lazycodex-ai 5.1.63 → 5.1.65

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/scripts/install-dist/install-local.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// omo-codex-install:ebe09a4bde119ce98f2acce7f1f2bcec3085e797964a5e3cf176873e4c1a81d7:c88063ed768fc19cb863c26d6e6592a599b331f0e45cd3c27fcc278e4c9bc51a
+// omo-codex-install:adc0c9ae0db7b2199d87a87956f2a065f91ef403e2c0816a4fe17111125c47b1:6fec9dd74fa6bb69f9064c703c94e024377de335a2c86ac93c5bd141b1290e69
 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.63",
+    version: "5.1.65",
     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