omo-ai 5.0.0 → 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,14 +1,15 @@
 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"
 import { migrateLegacyBunGlobalManifest } from "./legacy-bun-global-migration.js"
 import { adoptLegacyFlatState, canonicalAgentDir } from "./agent-dir.js"
-import { nearestNodeBin, packageManifest, packageRoot, readJson, releaseChannel, resolveSenpi, updateTarget } from "./package-paths.js"
+import { nearestNodeBin, packageManifest, packageRoot, readJson, releaseBanner, releaseChannel, resolveSenpi, updateTarget } from "./package-paths.js"
 import { runSelfUpdate } from "./self-update.js"
 import { detectHarnesses } from "./setup-detect.js"
 import { readSetupSuggestionCache, spawnSetupSuggestionRefresh } from "./setup-detect-cache.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,12 +275,18 @@ 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
   }
   if (isInteractiveDefault(args)) {
-    console.error(`omo (omo-ai beta ${packageManifest().version})`)
+    console.error(releaseBanner())
     if (process.stdout.isTTY === true && setupSuggestionForLaunch()) {
       console.error("omo: sibling credentials detected; run `omo setup` to review them")
     }

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"
 
@@ -19,6 +20,11 @@ export function releaseChannel(version = packageManifest().version) {
   return typeof version === "string" && version.includes("-") ? "beta" : "latest"
 }
 
+/** The startup banner line: a prerelease names its beta channel, a stable release does not. */
+export function releaseBanner(version = packageManifest().version) {
+  return releaseChannel(version) === "beta" ? `omo (omo-ai beta ${version})` : `omo (omo-ai ${version})`
+}
+
 /** The package spec that installs this build's channel: `omo-ai@beta` or the bare `omo-ai`. */
 export function channelPackageSpec(version = packageManifest().version) {
   return releaseChannel(version) === "beta" ? "omo-ai@beta" : "omo-ai"
@@ -32,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.26 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.0",
+  "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.26"
+    "@code-yeongyu/senpi": "2026.9.28-7"
   },
   "repository": {
     "type": "git",