omo-ai 5.0.1 → 5.1.0

package/bin/lib/computer-use-doctor.js

@@ -0,0 +1,90 @@
+import { join } from "node:path"
+import { pathToFileURL } from "node:url"
+import { packageManifest, packageRoot } from "./package-paths.js"
+
+export const COMPUTER_USE_RUNTIME = join("plugin", "runtime", "category-coverage", "index.js")
+
+async function loadRuntime() {
+  return import(pathToFileURL(join(packageRoot, COMPUTER_USE_RUNTIME)).href)
+}
+
+function baseLine(report) {
+  return `INFO computer use: enabled=${report.enabled} supported=${report.supported} host=${report.host}`
+}
+
+function readyLines(report) {
+  const capabilities = report.capabilities
+  const displayServer = capabilities.displayServer ? ` (${capabilities.displayServer})` : ""
+  const backendLevel = capabilities.backend === "unavailable" ? "WARN" : "PASS"
+  const permissionLevel = capabilities.capture && capabilities.input && capabilities.ax ? "PASS" : "WARN"
+  const displayLevel = capabilities.displayCount > 0 && !capabilities.screenLocked ? "PASS" : "WARN"
+  const stopLevel = capabilities.stopPath === "none" ? "WARN" : "PASS"
+  const stopReason = capabilities.stopReason ? ` reason=${capabilities.stopReason}` : ""
+  // The engine arms the stop chord only when a session starts input (`stopPath.start`), so a pre-session
+  // probe always sees `none` / `no-global-listener`; that is the normal idle state, not a failure.
+  const stopLine =
+    capabilities.stopPath === "none" && capabilities.stopReason === "no-global-listener"
+      ? "INFO computer use stop path: not armed until computer use starts input (checked when a session activates)"
+      : `${stopLevel} computer use stop path: ${capabilities.stopPath}${stopReason}`
+  return [
+    baseLine(report),
+    `PASS computer use engine: ${report.enginePath} (version ${report.hello.engineVersion}, ABI ${report.hello.abi}, protocol ${report.hello.protocolVersion})`,
+    `${backendLevel} computer use backend: ${capabilities.backend}${displayServer}`,
+    `${permissionLevel} computer use permissions: capture=${capabilities.capturePermission} input=${capabilities.inputPermission} accessibility=${capabilities.axPermission}`,
+    `${displayLevel} computer use display: count=${capabilities.displayCount} screenLocked=${capabilities.screenLocked}`,
+    stopLine,
+  ]
+}
+
+export function formatComputerUseDoctorLines(report) {
+  switch (report.kind) {
+    case "ready":
+      return readyLines(report)
+    case "skipped":
+      return [
+        baseLine(report),
+        report.reason === "disabled"
+          ? "INFO computer use probe: skipped because computer.enabled=false"
+          : `INFO computer use probe: skipped because ${report.host} is unsupported`,
+      ]
+    case "unavailable":
+      return [
+        baseLine(report),
+        `FAIL computer use engine: ${report.diagnostic.code}: ${report.diagnostic.message} ${report.diagnostic.cause}`.trimEnd(),
+        `INFO computer use engine paths tried: ${report.diagnostic.attemptedPaths.join(", ") || "<none>"}`,
+      ]
+    case "not-installed":
+      return [
+        baseLine(report),
+        "INFO computer use engine: not installed yet; it is downloaded the first time computer use starts",
+        `INFO computer use engine paths checked: ${report.attemptedPaths.join(", ") || "<none>"}`,
+      ]
+    case "failed":
+      return [
+        baseLine(report),
+        `FAIL computer use engine: ${report.code}: ${report.message}`,
+        `INFO computer use engine path: ${report.enginePath}`,
+      ]
+    default:
+      throw new TypeError(`unknown computer use doctor report kind: ${String(report.kind)}`)
+  }
+}
+
+export async function doctorComputerUseLines(options = {}) {
+  try {
+    const runtime = await (options.loadRuntime ?? loadRuntime)()
+    const report = await runtime.computerUseDoctorReport({
+      cwd: options.cwd ?? process.cwd(),
+      env: options.env ?? process.env,
+      version: packageManifest().version,
+      packageRoot,
+      platform: options.platform ?? process.platform,
+      arch: options.arch ?? process.arch,
+      timeoutMs: options.timeoutMs,
+    })
+    return formatComputerUseDoctorLines(report)
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    return [`WARN computer use: diagnostics unavailable: ${message}`]
+  }
+}

package/bin/lib/doctor-migration.js

@@ -4,6 +4,7 @@ import { delimiter, dirname, isAbsolute, join, win32 } from "node:path"
 import { parseJsonc } from "./jsonc.js"
 import { releaseChannel } from "./package-paths.js"
 import { opencodeConfigSources } from "./setup-opencode-assets.js"
+import { standaloneBinaryVersion } from "./standalone-binary.js"
 
 // Migration leftovers from the OpenCode edition, reported and never touched: another `omo` ahead of
 // omo-ai's on PATH, the legacy package still installed globally, and the OpenCode plugin still
@@ -51,7 +52,7 @@ export function resolveMigrationEnvironment({ env, platform, homeDir }) {
     ...opencode.files,
     ...opencode.directories.flatMap((directory) => TUI_CONFIG_FILES.map((name) => join(directory, name))),
   ]
-  return { isWindows, pathDirectories, npmPrefixes, bunRoot, opencodeConfigFiles }
+  return { isWindows, homeDir, pathDirectories, npmPrefixes, bunRoot, opencodeConfigFiles }
 }
 
 function npmrcPrefix(homeDir) {
@@ -72,15 +73,27 @@ export function scanOmoBins(environment) {
     const binPath = suffixes.map((suffix) => join(directory, `omo${suffix}`)).find(pathExists)
     if (binPath === undefined) continue
     const owner = resolveOwner(binPath)
-    entries.push({ binPath, directory, owner, kind: classify(owner) })
+    const kind = classify(owner)
+    const standalone = kind === "foreign" ? standaloneBinaryVersion(binPath, environment.homeDir, environment.isWindows) : null
+    entries.push(standalone === null
+      ? { binPath, directory, owner, kind }
+      : { binPath, directory, owner: { name: STANDALONE_LABEL, version: standalone }, kind: "standalone" })
   }
   return entries
 }
 
-/** The entries a typed `omo` reaches before omo-ai's own; all of them when omo-ai is not on PATH. */
+const STANDALONE_LABEL = "standalone omo binary"
+const isOmoInstall = (entry) => entry.kind === "native" || entry.kind === "standalone"
+
+/** The entries a typed `omo` reaches before OmO's own (omo-ai or a standalone binary); all of them when neither is on PATH. */
 export function shadowingOmoBins(entries) {
-  const nativeIndex = entries.findIndex((entry) => entry.kind === "native")
-  return (nativeIndex < 0 ? entries : entries.slice(0, nativeIndex)).filter((entry) => entry.kind !== "native")
+  const firstOmo = entries.findIndex(isOmoInstall)
+  return (firstOmo < 0 ? entries : entries.slice(0, firstOmo)).filter((entry) => !isOmoInstall(entry))
+}
+
+/** omo-ai and standalone binaries on PATH, in PATH order; only the first one runs. */
+export function omoInstallsOnPath(entries) {
+  return entries.filter(isOmoInstall)
 }
 
 function classify(owner) {
@@ -105,13 +118,16 @@ function resolveOwner(binPath) {
   const fromLink = isInsideNodeModules(real) ? ownerOfFile(real) : null
   if (fromLink !== null) return fromLink
   const shim = readFileHead(binPath, SHIM_READ_LIMIT)
-  if (shim === undefined) return null
-  if (shim.includes(CODEX_LIGHT_WRAPPER_MARKER)) {
+  if (shim?.includes(CODEX_LIGHT_WRAPPER_MARKER)) {
     const version = shim.match(CODEX_LIGHT_CACHE_VERSION)?.[1]
     if (version !== undefined) return { name: "lazycodex", version }
   }
-  // Ownership comes from an installed package the shim really launches, never from its text alone.
-  for (const entry of shimEntryPaths(shim, dirname(binPath))) {
+  // Ownership comes from an installed package the shim or its Bun sidecar really launches, never text alone.
+  const entries = [
+    ...(shim === undefined ? [] : shimEntryPaths(shim, dirname(binPath))),
+    ...bunxEntryPaths(binPath),
+  ]
+  for (const entry of entries) {
     if (!isInsideNodeModules(entry) || !pathExists(entry)) continue
     const owner = ownerOfFile(entry)
     if (owner !== null) return owner
@@ -132,6 +148,24 @@ function shimEntryPaths(shim, shimDirectory) {
   return paths
 }
 
+// Bun's Windows bin is a copied `omo.exe` plus an `omo.bunx` sidecar: UTF-16LE, the target path up to
+// a `"` and a NUL. Bun writes that path relative to the bin dir's parent (`..\node_modules\...` or
+// `install\global\node_modules\...` from `~/.bun`), and its shim resolves it against that same dir.
+function bunxEntryPaths(binPath) {
+  if (!/\.exe$/i.test(binPath)) return []
+  const sidecar = `${binPath.slice(0, -4)}.bunx`
+  let contents
+  try {
+    if (!statSync(sidecar).isFile()) return []
+    contents = readFileSync(sidecar).toString("utf16le")
+  } catch {
+    return []
+  }
+  const end = contents.indexOf('"\0')
+  if (end <= 0) return []
+  return [join(dirname(dirname(binPath)), contents.slice(0, end).replace(/\\/g, "/"))]
+}
+
 function isInsideNodeModules(path) {
   return /(?:^|[\\/])node_modules[\\/]/.test(path)
 }
@@ -243,23 +277,39 @@ function isPluginEntryFor(entry, name) {
 
 function ownerLabel(owner) {
   if (owner === null) return "unknown owner"
+  if (owner.name === STANDALONE_LABEL) return `${owner.name} ${owner.version}`
   return owner.version === null ? owner.name : `${owner.name}@${owner.version}`
 }
 
-export function formatMigrationLines({ shadowing, nativeDirectory, legacyPackages, registrations, restoreCommand }) {
+function omoInstallRemoval(entry, bunRoot) {
+  if (entry.kind === "standalone") return `remove ${entry.binPath}`
+  return realPathOf(entry.binPath).startsWith(realPathOf(bunRoot)) ? "bun remove -g omo-ai" : "npm uninstall -g omo-ai"
+}
+
+export function formatMigrationLines({ shadowing, nativeDirectory, legacyPackages, registrations, restoreCommand, omoInstalls = [], bunRoot = "", standalone = false }) {
   const lines = []
+  const first = omoInstalls[0]
+  const target = first?.kind === "standalone" || (first === undefined && standalone) ? "the standalone omo binary" : "omo-ai"
   for (const entry of shadowing) {
-    const fix = entry.kind === "legacy"
+    const fix = entry.kind === "legacy" && target === "omo-ai"
       ? `${repairCommand()} (repairs it), or remove that file.`
       : nativeDirectory === null
-        ? "remove that file, or put omo-ai's bin dir ahead of it on PATH."
+        ? `remove that file, or put ${target === "omo-ai" ? "omo-ai's bin dir" : "the omo binary's directory"} ahead of it on PATH.`
         : `remove that file, or move ${nativeDirectory} ahead of ${entry.directory} on PATH.`
-    lines.push(`WARN another omo precedes omo-ai on PATH: ${entry.binPath} (${ownerLabel(entry.owner)}). Fix: ${fix}`)
+    lines.push(`WARN another omo precedes ${target} on PATH: ${entry.binPath} (${ownerLabel(entry.owner)}). Fix: ${fix}`)
+  }
+  const shadowedOmo = omoInstalls.slice(1).filter((entry) => entry.kind !== first.kind || entry.kind === "standalone")
+  if (shadowedOmo.length > 0) {
+    const others = shadowedOmo.map((entry) => `${entry.binPath} (${ownerLabel(entry.owner)})`).join(", ")
+    const removals = shadowedOmo.map((entry) => omoInstallRemoval(entry, bunRoot)).join(" and ")
+    lines.push(`WARN more than one OmO install is on PATH: ${first.binPath} (${ownerLabel(first.owner)}) runs when you type omo; ${others} never runs. Keep one: ${removals}, or ${omoInstallRemoval(first, bunRoot)} to use the other.`)
   }
   for (const found of legacyPackages) {
     const label = ownerLabel({ name: found.name, version: found.version })
     const remove = found.manager === "npm"
-      ? `npm uninstall -g ${found.name}, then re-run ${restoreCommand} if omo disappears.`
+      ? restoreCommand === null
+        ? `npm uninstall -g ${found.name}`
+        : `npm uninstall -g ${found.name}, then re-run ${restoreCommand} if omo disappears.`
       : `bun remove -g ${found.name}`
     lines.push(`WARN legacy package ${label} is still installed globally (${found.manager}: ${found.packageDir}). Remove: ${remove}`)
   }
@@ -279,11 +329,15 @@ export function migrationReport(options, restoreCommand) {
     homeDir: options.homeDir ?? homedir(),
   })
   const bins = scanOmoBins(environment)
+  const omoInstalls = omoInstallsOnPath(bins)
   return formatMigrationLines({
     shadowing: shadowingOmoBins(bins),
-    nativeDirectory: bins.find((entry) => entry.kind === "native")?.directory ?? null,
+    nativeDirectory: omoInstalls[0]?.directory ?? null,
     legacyPackages: findLegacyPackages(environment),
     registrations: findOpenCodeRegistrations(environment.opencodeConfigFiles),
     restoreCommand,
+    omoInstalls,
+    bunRoot: environment.bunRoot,
+    standalone: options.standalone === true,
   })
 }

package/bin/lib/doctor.js

@@ -433,8 +433,8 @@ export function runDoctor(inventory, args = [], options = {}) {
   lines.push(...staleEngineReport(options))
   lines.push(...retiredPayloadReport(options))
   lines.push(...transientMemoryReport(options))
-  lines.push(...daemonReport(options))
-  lines.push(...(options.categoryCoverage ?? []))
+  lines.push(...daemonReport(options), ...(options.computerUse ?? []), ...(options.categoryCoverage ?? []))
+  if ((options.computerUse ?? []).some((line) => line.startsWith("FAIL "))) failed = true
   if (needsSetupSuggestion(inventory)) {
     lines.push("INFO no credentials found; run omo setup to review sibling stores")
   }

package/bin/lib/launcher.js

@@ -1,8 +1,9 @@
 import { spawnSync } from "node:child_process"
-import { existsSync } from "node:fs"
-import { delimiter, join } from "node:path"
+import { existsSync, realpathSync } from "node:fs"
+import { delimiter, isAbsolute, join, relative, sep } from "node:path"
 import { spawnNode } from "./child-process.js"
 import { doctorCoverageLines } from "./category-coverage.js"
+import { doctorComputerUseLines } from "./computer-use-doctor.js"
 import { runDaemonCommand } from "./daemon.js"
 import { runDoctor } from "./doctor.js"
 import { ensureEnginePrepared } from "./engine-prepare.js"
@@ -78,10 +79,35 @@ function engineVersion() {
   }
 }
 
+function canonicalPath(path) {
+  try {
+    return realpathSync.native(path)
+  } catch {
+    return path
+  }
+}
+
+function containsPath(root, target) {
+  const rel = relative(canonicalPath(root), canonicalPath(target))
+  return rel === "" || (rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel))
+}
+
+// A compiled omo session exports its own payload as the brand-scoped package dir, and every shell it
+// spawns inherits that. The engine reads these names before the legacy PI_PACKAGE_DIR, so a release
+// omo started from such a shell would run on the foreign payload. A deliberate relocation names this
+// install's engine and survives; a root that does not contain the engine belongs to another install.
+function dropForeignPackageDirs(env, senpiRoot) {
+  for (const name of ["OMO_PACKAGE_DIR", "SENPI_PACKAGE_DIR"]) {
+    const root = env[name]
+    if (root && !containsPath(root, senpiRoot)) delete env[name]
+  }
+}
+
 function senpiEnvironment(senpiRoot) {
   const env = { ...process.env }
   delete env.OMO_BIN
   delete env.SENPI_BIN
+  dropForeignPackageDirs(env, senpiRoot)
   // One directory for every surface. The legacy name travels too, so a bare senpi spawned by a
   // tool inherits the same state instead of falling back to its own home.
   const agentDir = canonicalAgentDir(env)
@@ -220,8 +246,17 @@ export async function runLauncher(args = process.argv.slice(2)) {
     return
   }
   if (command === "doctor") {
-    const categoryCoverage = args[1] === "--reap" ? [] : await doctorCoverageLines({ agentDir: canonicalAgentDir() })
-    runDoctor(await detectHarnesses(), args.slice(1), { daemonEngine: { run: engineHostCall }, categoryCoverage })
+    const [categoryCoverage, computerUse] = args[1] === "--reap"
+      ? [[], []]
+      : await Promise.all([
+          doctorCoverageLines({ agentDir: canonicalAgentDir() }),
+          doctorComputerUseLines(),
+        ])
+    runDoctor(await detectHarnesses(), args.slice(1), {
+      daemonEngine: { run: engineHostCall },
+      categoryCoverage,
+      computerUse,
+    })
     return
   }
   if (command === "setup") {
@@ -240,6 +275,12 @@ export async function runLauncher(args = process.argv.slice(2)) {
     process.exitCode = await runSelfUpdate(args)
     return
   }
+  // app-server takes the plugin after its subcommand: a leading --extension never reaches the
+  // engine's app-server dispatch. It loads into every thread, including the daemon's.
+  if (command === "app-server") {
+    await spawnSenpi(args.includes("--no-extensions") ? args : [...args, "--extension", join(packageRoot, "plugin")], false)
+    return
+  }
   if (earlyCommands.has(command) || command === "update") {
     await spawnSenpi(args, false)
     return

package/bin/lib/package-paths.js

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync } from "node:fs"
+import { homedir } from "node:os"
 import { basename, dirname, join, parse } from "node:path"
 import { fileURLToPath } from "node:url"
 
@@ -37,21 +38,32 @@ function installedVersion(root) {
   }
 }
 
-export function updateTarget(root = packageRoot, platform = process.platform, version = installedVersion(root)) {
+export function updateTarget(
+  root = packageRoot,
+  platform = process.platform,
+  version = installedVersion(root),
+  homeDir = process.env.HOME || process.env.USERPROFILE || homedir(),
+  exists = existsSync,
+) {
   const spec = channelPackageSpec(version)
   const updateCwd = dirname(join(root, "package.json"))
   const normalizedRoot = updateCwd.replaceAll("\\", "/")
-  if (normalizedRoot.endsWith(BUN_GLOBAL_PACKAGE_SUFFIX)) {
+  const normalizedHome = homeDir.replaceAll("\\", "/").replace(/\/+$/, "")
+  const bunInstall = normalizedRoot.endsWith(BUN_GLOBAL_PACKAGE_SUFFIX)
+    ? normalizedRoot.slice(0, -BUN_GLOBAL_PACKAGE_SUFFIX.length)
+    : undefined
+  const isLegacyBunGlobal = normalizedRoot === `${normalizedHome}/node_modules/omo-ai`
+    && (exists(join(homeDir, "bun.lock")) || exists(join(homeDir, "bun.lockb")))
+  if (bunInstall !== undefined || isLegacyBunGlobal) {
     // `--cwd` into this package dir does not retarget `bun add -g`; bun still installs into
     // `$BUN_INSTALL/install/global` (or `~/.bun` when that env is unset). The prefix is the
     // ancestor of `/install/global/`, and the spawn overlays it so this install is the one that
-    // moves. `platform` stays on the signature because callers pass the host they are describing.
-    const bunInstall = normalizedRoot.slice(0, -BUN_GLOBAL_PACKAGE_SUFFIX.length)
+    // moves. A legacy Bun home-root install must carry Bun's lockfile and keeps its ambient configuration.
     return {
       manager: "bun",
       command: `bun add -g ${spec}`,
       argv: ["bun", "add", "-g", spec],
-      env: { BUN_INSTALL: bunInstall },
+      ...(bunInstall === undefined ? {} : { env: { BUN_INSTALL: bunInstall } }),
     }
   }
   return {

package/bin/lib/provider-map.json

@@ -1,5 +1,5 @@
 {
-  "_comment": "Derived from @code-yeongyu/senpi 2026.9.27 builtinProviders(). builtinProviderIds and oauthProviderIds are the engine registry verbatim; providers maps a source harness id onto the omo provider that serves the same endpoint; oauthLogins maps a source OAuth id onto the omo provider to run /login for. Re-derive all four whenever the senpi pin changes.",
+  "_comment": "Derived from @code-yeongyu/senpi 2026.9.28-7 builtinProviders(). builtinProviderIds and oauthProviderIds are the engine registry verbatim; providers maps a source harness id onto the omo provider that serves the same endpoint; oauthLogins maps a source OAuth id onto the omo provider to run /login for. Re-derive all four whenever the senpi pin changes.",
   "builtinProviderIds": [
     "alibaba-token-plan",
     "amazon-bedrock",

package/bin/lib/standalone-binary.js

@@ -0,0 +1,67 @@
+import { closeSync, openSync, readdirSync, readSync, realpathSync, statSync } from "node:fs"
+import { join } from "node:path"
+
+const SAMPLE_BYTES = 64 * 1024
+
+// A compiled omo copies itself to ~/.omo/binary-runtime/<version>/omo on its first run
+// (materializeProvisionedExecutable in compile-runtime.ts), so a standalone binary that has run
+// once is that file or a byte-identical copy of it. Copies are compared by size and a bounded
+// head+tail sample: these binaries are ~100 MB and the doctor must stay fast.
+export function standaloneBinaryVersion(binPath, homeDir, isWindows) {
+  const root = join(homeDir, ".omo", "binary-runtime")
+  let versions
+  try {
+    versions = readdirSync(root)
+  } catch {
+    return null
+  }
+  const real = realPathOf(binPath)
+  const size = regularFileSize(real)
+  if (size === undefined) return null
+  for (const version of versions) {
+    const provisioned = realPathOf(join(root, version, isWindows ? "omo.exe" : "omo"))
+    if (provisioned === real) return version
+    if (regularFileSize(provisioned) === size && sameSamples(real, provisioned, size)) return version
+  }
+  return null
+}
+
+function realPathOf(path) {
+  try {
+    return realpathSync(path)
+  } catch {
+    return path
+  }
+}
+
+function regularFileSize(path) {
+  try {
+    const stats = statSync(path)
+    return stats.isFile() ? stats.size : undefined
+  } catch {
+    return undefined
+  }
+}
+
+function sameSamples(left, right, size) {
+  const length = Math.min(SAMPLE_BYTES, size)
+  const tail = Math.max(0, size - length)
+  const a = readSamples(left, length, tail)
+  const b = readSamples(right, length, tail)
+  return a !== undefined && b !== undefined && a.equals(b)
+}
+
+function readSamples(path, length, tailOffset) {
+  let descriptor
+  try {
+    descriptor = openSync(path, "r")
+    const buffer = Buffer.alloc(length * 2)
+    readSync(descriptor, buffer, 0, length, 0)
+    readSync(descriptor, buffer, length, length, tailOffset)
+    return buffer
+  } catch {
+    return undefined
+  } finally {
+    if (descriptor !== undefined) closeSync(descriptor)
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omo-ai",
-  "version": "5.0.1",
+  "version": "5.1.0",
   "type": "module",
   "description": "OmO Native - the standalone omo command with the OMO extension built in: bun add -g omo-ai",
   "bin": {
@@ -18,7 +18,7 @@
   },
   "dependencies": {
     "@babel/parser": "8.0.4",
-    "@code-yeongyu/senpi": "2026.9.27"
+    "@code-yeongyu/senpi": "2026.9.28-7"
   },
   "repository": {
     "type": "git",

package/plugin/CHANGELOG.md

@@ -7,6 +7,123 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [5.1.0] - 2026-09-28
+
+5.1.0 adds computer use to OmO Native as an experimental feature, and fixes Claude subscription logins across many sessions, GitHub Copilot tokens and hosts, goals that looped on a rejected login, and a long list of background task problems. `omo update` installs it, or run:
+
+```bash
+bun add -g omo-ai
+```
+
+### Computer use (experimental)
+
+- **Experimental:** OmO Native agents can now drive your real desktop. They take screenshots, list windows, click, type, scroll, press keys, read the accessibility tree and use the clipboard, through a `computer` tool and a `computer` global in the eval kernels. Behaviour may still change, so please send feedback and bug reports.
+- **Per OS:**
+  - macOS (arm64, x64): background input by default, so your frontmost app, focus and cursor stay put.
+  - Windows x64: background input varies by app, and nothing can reach elevated apps.
+  - Linux x64 on X11: XTEST/XSendEvent plus AT-SPI.
+  - Linux x64 on Wayland: portals and libei, with no single-window capture.
+  - No engine ships yet for Linux arm64 or Windows arm64.
+- **Turning it on:** it is on by default on supported hosts, but its code and native engine load only on first use, so sessions that never use it pay nothing at startup. The agent finds `computer` through tool search, or you run `/computer on`. `/computer status` shows the engine, the stop path and the OS permissions. Set `computer.enabled: false` to remove it entirely. macOS needs Screen Recording and Accessibility.
+- **Scrolling:** `dx`/`dy` are pixels on every OS (one wheel notch is 40 px), and a positive `dy` scrolls down everywhere, macOS included. ([#9101](https://github.com/code-yeongyu/oh-my-openagent/issues/9101), [#9055](https://github.com/code-yeongyu/oh-my-openagent/issues/9055))
+- **Kill switch:** Control+Option+Command+Escape on macOS, or Ctrl+Alt+Shift+Escape on Linux and Windows, stops all computer input at once, including typing already in progress. Input stays stopped until you run `/computer resume`; the agent cannot resume it.
+- **Safety:** screenshots need `computer:read` and input needs `computer:exec`. Before input, OmO checks the stop path, the screen lock, the OS permissions and that the target point is uncovered.
+- **Known limits:** some toolkits ignore synthetic background input; OmO then reports it instead of pretending it worked. X11 background input doesn't reach GTK, Qt or Chromium yet (#9108). Wayland's stop chord needs the GlobalShortcuts portal. Full guide: [`docs/guide/computer-use.md`](https://github.com/code-yeongyu/oh-my-openagent/blob/dev/docs/guide/computer-use.md).
+
+### Added
+
+- `omo app-server` threads load the OmO plugin, so they get `task`, `workpool`, `memory`, `lsp_*` and the other OmO tools, and `app-server daemon restart` keeps it. ([#9117](https://github.com/code-yeongyu/oh-my-openagent/issues/9117), [#9122](https://github.com/code-yeongyu/oh-my-openagent/pull/9122), [senpi#2313](https://github.com/code-yeongyu/senpi/issues/2313))
+- Durable scheduled prompts: the `schedule_prompt` tool stores a reminder, follow-up or recurring prompt, and `schedule run` fires it later, also for `--print` runs. ([senpi#2216](https://github.com/code-yeongyu/senpi/issues/2216))
+- Sessions follow a moved or re-cloned repository: `--session`, `--resume` and `/resume` offer to move them here, keeping their history, goal, loops and monitors. ([senpi#2181](https://github.com/code-yeongyu/senpi/issues/2181), [senpi#2184](https://github.com/code-yeongyu/senpi/issues/2184))
+- `models discover <provider>` fills an OpenAI-compatible provider's model list in `models.json` from its `/models` endpoint, including the reasoning levels it advertises. ([senpi#2196](https://github.com/code-yeongyu/senpi/issues/2196))
+- Eval kernels say when they hold a lot of memory, name the largest globals, and restart once past a ceiling (`memory.noticeMb`, `memory.ceilingMb`). ([senpi#2261](https://github.com/code-yeongyu/senpi/issues/2261))
+- `host status --all` lists every RPC host endpoint, `host gc` clears the state of hosts that are provably gone, and `host status` shows `memory_pressure`. ([senpi#2226](https://github.com/code-yeongyu/senpi/issues/2226), [senpi#2245](https://github.com/code-yeongyu/senpi/issues/2245))
+- A native crash of an interactive or print session leaves one entry in `process-crashes/crashes.jsonl` on the next start. ([senpi#2194](https://github.com/code-yeongyu/senpi/issues/2194))
+
+### Changed
+
+- OmO Native moves from senpi 2026.9.27 to senpi 2026.9.28-7; the engine fixes below come with it.
+- A parent no longer runs out of room for its task children: `task.residency_max_children` defaults to `"unlimited"`. Set a number in `omo.json` to keep a bound. ([#8999](https://github.com/code-yeongyu/oh-my-openagent/issues/8999))
+- Memory extracts facts from one very long conversation entry (up to 512 KiB) in a bounded extra run instead of parking it forever, which can mean extra model calls. ([#8984](https://github.com/code-yeongyu/oh-my-openagent/issues/8984), contributed by @deadcode-walker in [#8985](https://github.com/code-yeongyu/oh-my-openagent/pull/8985))
+- After an account-wide usage limit, a task's fallback tries the next provider's models first and keeps the spent provider as the last resort; a limit on one model or family still moves to the next model in order. ([#8296](https://github.com/code-yeongyu/oh-my-openagent/issues/8296))
+- A fallback-chain model that keeps failing is skipped for a cooldown (60 s, doubling up to 30 minutes) by every session in the process, and a provider's `Retry-After` is honored. ([senpi#2198](https://github.com/code-yeongyu/senpi/issues/2198))
+- GPT-6 Astra, Sol and Luna stay on the stated goal and report unrelated errors in the final message instead of chasing them. ([senpi#2256](https://github.com/code-yeongyu/senpi/issues/2256))
+- OpenCode Go and Fireworks default to `kimi-k3`, since their old Kimi defaults left the catalogs. ([senpi#2295](https://github.com/code-yeongyu/senpi/issues/2295), [senpi#2175](https://github.com/code-yeongyu/senpi/issues/2175))
+
+### Fixed
+
+**Providers and logins**
+
+- Claude subscription sessions no longer hit `401 OAuth access token has been revoked` and end up "blocked until re-login" when several sessions run at once; they pick up the refreshed token instead. ([#8762](https://github.com/code-yeongyu/oh-my-openagent/issues/8762), [senpi#2225](https://github.com/code-yeongyu/senpi/issues/2225), [senpi#2281](https://github.com/code-yeongyu/senpi/issues/2281), [senpi#2282](https://github.com/code-yeongyu/senpi/issues/2282))
+- `/login` into a blocked Claude account now replaces the revoked token instead of keeping it. ([senpi#2222](https://github.com/code-yeongyu/senpi/issues/2222))
+- A Claude subscription turn no longer fails with "pre-replay buffer overflow" while Claude Code runs a background turn of its own. ([senpi#2192](https://github.com/code-yeongyu/senpi/issues/2192))
+- GitHub Copilot recovers when GitHub revokes its cached token: the token is re-exchanged once and the request re-sent, so every model no longer fails with HTTP 403 until `/login`. ([senpi#2297](https://github.com/code-yeongyu/senpi/issues/2297), [senpi#2302](https://github.com/code-yeongyu/senpi/issues/2302))
+- GitHub Copilot Business and Enterprise accounts reach their own API host instead of failing with `421 Misdirected Request`, for chat, `/btw` and web search. ([#8662](https://github.com/code-yeongyu/oh-my-openagent/issues/8662), [senpi#2309](https://github.com/code-yeongyu/senpi/issues/2309), [senpi#2310](https://github.com/code-yeongyu/senpi/issues/2310))
+- Copilot turns no longer fail with a bare HTTP 400 when more than 128 tools are exposed; the extras are left out and you're told how many. ([senpi#2298](https://github.com/code-yeongyu/senpi/issues/2298))
+- Copilot models compact before Copilot's own prompt limit instead of failing the turn. ([senpi#2299](https://github.com/code-yeongyu/senpi/issues/2299))
+- A Copilot 402, 403 or quota 429 says whether it's a quota or a refusal and includes the GitHub request id. ([senpi#2297](https://github.com/code-yeongyu/senpi/issues/2297))
+- A goal stops on the first 401 or 403 a provider keeps returning and tells you what to do (for example `Run /login github-copilot ...`) instead of looping to the continuation cap; your next message resumes it. ([senpi#2293](https://github.com/code-yeongyu/senpi/issues/2293))
+- The first message no longer fails on providers that only accept automatic tool choice, for example Kiro behind a proxy; `compat.supportsForcedToolChoice: false` skips the forced choice entirely. ([#9096](https://github.com/code-yeongyu/oh-my-openagent/issues/9096), [senpi#2218](https://github.com/code-yeongyu/senpi/issues/2218), [senpi#2224](https://github.com/code-yeongyu/senpi/issues/2224))
+- Devin SWE-2 lists only the lanes Devin serves (`swe-2-medium`, `swe-2-high`, `swe-2-max`), `devin/swe-2-medium` gets the SWE-2 prompt preset, and a config naming `swe-2`, `swe-2-low` or `swe-2-high-lite` gets a startup warning. ([#9111](https://github.com/code-yeongyu/oh-my-openagent/issues/9111), [senpi#2306](https://github.com/code-yeongyu/senpi/issues/2306), [senpi#2308](https://github.com/code-yeongyu/senpi/issues/2308))
+
+**Memory**
+
+- Kibitzer and the other memory sidecars fall back to their category's builtin models when a pinned model refuses, instead of failing every wake. ([#9111](https://github.com/code-yeongyu/oh-my-openagent/issues/9111))
+- The Kibitzer failure notice names the model that failed and the `omo.json` setting to change. ([#9111](https://github.com/code-yeongyu/oh-my-openagent/issues/9111))
+- Memory reflection moves to the next model when one hits a spent usage or quota limit, instead of ending the run. ([#8296](https://github.com/code-yeongyu/oh-my-openagent/issues/8296), [#6808](https://github.com/code-yeongyu/oh-my-openagent/issues/6808))
+- Memory dreaming sees which skills and memory files you actually read again. ([#8864](https://github.com/code-yeongyu/oh-my-openagent/issues/8864), reported by @katamana, fixed by @MoerAI in [#8865](https://github.com/code-yeongyu/oh-my-openagent/pull/8865))
+
+**Tasks and subagents**
+
+- Task children wait for a busy task host instead of failing with "Task runner failed to start." within 30 s. ([#9067](https://github.com/code-yeongyu/oh-my-openagent/issues/9067), [senpi#2209](https://github.com/code-yeongyu/senpi/issues/2209))
+- A task child that kept working through a host hiccup or handoff is no longer left "suspended" until the parent restarts. ([#9069](https://github.com/code-yeongyu/oh-my-openagent/issues/9069))
+- A task waiting for a free slot on its fallback model shows as queued with its position, not as running. ([#9069](https://github.com/code-yeongyu/oh-my-openagent/issues/9069))
+- A task's status follows its child: a nudged child no longer shows as failed, and a child that wakes up on its own sends a `task completion (resumed turn)`. ([#9069](https://github.com/code-yeongyu/oh-my-openagent/issues/9069))
+- A delegated task no longer hangs in `running` (and `omo -p` no longer stays open) when its first model fails and it moves to the next one.
+- A task child whose host restarted mid-turn continues its interrupted turn when the parent resumes. ([#9003](https://github.com/code-yeongyu/oh-my-openagent/issues/9003))
+- A suspended task child frees its concurrency slot, so `task_send` no longer answers `lane_capacity` after a few restarts. ([#8973](https://github.com/code-yeongyu/oh-my-openagent/issues/8973))
+- Task start failures say why the child couldn't start instead of only `Task runner failed to start.` ([#8960](https://github.com/code-yeongyu/oh-my-openagent/issues/8960))
+- A child whose host dies while it opens reports `host_unreachable`. ([#9020](https://github.com/code-yeongyu/oh-my-openagent/issues/9020))
+- A re-prompted child on a loaded host no longer prints `Timeout waiting for response to prompt` over the parent's screen. ([#9093](https://github.com/code-yeongyu/oh-my-openagent/issues/9093))
+- A task whose whole fallback chain failed says so in its transcript. ([#8301](https://github.com/code-yeongyu/oh-my-openagent/issues/8301), contributed by @MoerAI in [#9022](https://github.com/code-yeongyu/oh-my-openagent/pull/9022))
+- Live task progress, stats and transcripts keep updating after a child reconnects to its host. ([#8983](https://github.com/code-yeongyu/oh-my-openagent/issues/8983), contributed by @deadcode-walker in [#8978](https://github.com/code-yeongyu/oh-my-openagent/pull/8978))
+- DAG nodes finish when their child task finishes, also in projects reached through a symlink. ([#8932](https://github.com/code-yeongyu/oh-my-openagent/issues/8932), reported by @ayalcoh)
+- A cancel, a cleanup sweep or a reload during a model fallback no longer ends a revived run, loses a lane slot, or starts the next model beside a child that's still closing.
+
+**Task host**
+
+- The shared host keeps opening sessions after a session's directory is deleted, instead of failing every new task child with `ENOENT`. ([senpi#2206](https://github.com/code-yeongyu/senpi/issues/2206))
+- The shared host no longer refuses task children when its memory is high, and it leaves memory pressure once memory is actually freed. ([#8960](https://github.com/code-yeongyu/oh-my-openagent/issues/8960), [senpi#2207](https://github.com/code-yeongyu/senpi/issues/2207), [senpi#2261](https://github.com/code-yeongyu/senpi/issues/2261))
+- A transient task daemon idle-exits again while omo runs, and polling `host status` no longer keeps hosts alive. ([#9041](https://github.com/code-yeongyu/oh-my-openagent/issues/9041), [senpi#2242](https://github.com/code-yeongyu/senpi/issues/2242), [senpi#2227](https://github.com/code-yeongyu/senpi/issues/2227))
+- An old host generation exits after a handoff even when one of its sessions misbehaves, and a handoff no longer inherits the calling session's identity or model. ([senpi#2285](https://github.com/code-yeongyu/senpi/issues/2285), [senpi#2208](https://github.com/code-yeongyu/senpi/issues/2208))
+
+**Commands and sessions**
+
+- `/ulw-execute <plan>` and every bundled skill name work as bare commands, like `/skill:<name>`. ([#9042](https://github.com/code-yeongyu/oh-my-openagent/issues/9042))
+- A bare `/skill` or `/skill:` opens the skill list instead of going to the model. ([senpi#2249](https://github.com/code-yeongyu/senpi/issues/2249), [senpi#2251](https://github.com/code-yeongyu/senpi/issues/2251))
+- `/thinking` works again, `/sessions` opens the session picker, and `/help` says how to change the thinking level and reopen a session. ([senpi#1437](https://github.com/code-yeongyu/senpi/issues/1437))
+- Answering `y` to "Fork this session into current directory?" forks it instead of printing `Aborted.` ([senpi#2180](https://github.com/code-yeongyu/senpi/issues/2180), [senpi#1042](https://github.com/code-yeongyu/senpi/pull/1042) by @beengineer500)
+- Starting omo no longer empties an upstream pi install, and a `~/.pi/agent` an earlier start drained gets its files copied back. ([#8039](https://github.com/code-yeongyu/oh-my-openagent/issues/8039), [senpi#2215](https://github.com/code-yeongyu/senpi/issues/2215))
+- MCP tools register once per session instead of twice. ([senpi#2177](https://github.com/code-yeongyu/senpi/issues/2177))
+- Unhandled errors go to the debug log instead of over the TUI, and a fatal crash prints one line with the log path. ([senpi#2284](https://github.com/code-yeongyu/senpi/issues/2284))
+- ulw plan progress counts `T1.2`, `F1`-style task ids and blocked `- [~]` rows, and a plan with no countable tasks no longer triggers a `0/0` continuation. ([#9019](https://github.com/code-yeongyu/oh-my-openagent/issues/9019), [#6233](https://github.com/code-yeongyu/oh-my-openagent/issues/6233))
+- Session search in the `coding-agent-sessions` skill finds prompts from the middle of a session. ([#9012](https://github.com/code-yeongyu/oh-my-openagent/issues/9012))
+
+**Edits and eval**
+
+- When the formatter rewrites a file after `write`, `edit` or `apply_patch`, the model always gets the "auto-formatted, re-read before exact-text edits" notice, also when diagnostics come back clean. ([#9123](https://github.com/code-yeongyu/oh-my-openagent/issues/9123))
+- The comment checker replaces a stale cached binary with the pinned release, and warns in the session when it can't run instead of going quiet. ([#8850](https://github.com/code-yeongyu/oh-my-openagent/issues/8850), contributed by @cynkai in [#8877](https://github.com/code-yeongyu/oh-my-openagent/pull/8877) and [#8880](https://github.com/code-yeongyu/oh-my-openagent/pull/8880))
+- `new Bun.WebView()` works in eval cells on Windows and Linux, and with `backend: "chrome"` on macOS, and no longer leaves Chrome running. ([senpi#2248](https://github.com/code-yeongyu/senpi/issues/2248), [senpi#2272](https://github.com/code-yeongyu/senpi/issues/2272))
+- Eval memory goes back to the machine without a reset, settled cells no longer pin their images in memory, and retired workers don't leave zombie processes. ([senpi#2259](https://github.com/code-yeongyu/senpi/issues/2259), [senpi#2260](https://github.com/code-yeongyu/senpi/issues/2260), [senpi#2261](https://github.com/code-yeongyu/senpi/issues/2261), [senpi#1962](https://github.com/code-yeongyu/senpi/issues/1962))
+- Eval cells that print a lot of output finish about 4x faster. ([senpi#2262](https://github.com/code-yeongyu/senpi/issues/2262))
+
+**Install, update and doctor**
+
+- `omo update` on a compiled binary picks the newest release on its own channel and the asset it was built as, and prints a command that replaces the running binary; the TUI update notice says `omo update`.
+- `omo doctor` treats a standalone omo binary as an OmO install instead of an unknown file to delete, and warns once when it and omo-ai are both on PATH.
+- On Windows, `omo doctor` and `install --platform=native` recognize a Bun-installed omo, and `omo update` uses `bun add -g` for a legacy Bun home install. ([#8909](https://github.com/code-yeongyu/oh-my-openagent/issues/8909))
+- The computer use engine for Intel Macs starts: it was built for macOS 10.12 and could not load its Swift libraries, and the release now runs its selftest under Rosetta. ([#9139](https://github.com/code-yeongyu/oh-my-openagent/pull/9139))
+
 ## [5.0.1] - 2026-09-27
 
 A patch release for problems people hit on 5.0.0. `omo update` installs it, or run: