omo-ai 5.1.2 → 5.1.4

package/bin/lib/doctor.js

@@ -3,60 +3,20 @@ import { existsSync, readFileSync, readdirSync, statSync } from "node:fs"
 import { homedir } from "node:os"
 import { join, resolve } from "node:path"
 import { canonicalAgentDir } from "./agent-dir.js"
-import { packageManifest, packageRoot, readJson, releaseChannel, resolveSenpi, updateTarget } from "./package-paths.js"
+import { fetchNpmDistTagsSync } from "./npm-dist-tags.js"
+import { channelDistTagVersion, packageManifest, packageRoot, readJson, releaseChannel, resolveSenpi, updateTarget } from "./package-paths.js"
 import { daemonReportLines } from "./daemon.js"
 import { migrationReport } from "./doctor-migration.js"
+import { launchSpecDoctorLines } from "./launch-spec-mode.js"
 import { piConfigReport } from "./doctor-pi-config.js"
 import { needsSetupSuggestion } from "./setup-detect.js"
 
-const NPM_DIST_TAGS_URL = "https://registry.npmjs.org/-/package/omo-ai/dist-tags"
-const NPM_FETCH_TIMEOUT_MS = 5000
-
-// Doctor is called without await from the launcher and the compiled entry, so the
-// registry lookup has to finish before we print. A bounded child fetch keeps that
-// synchronous and turns any network failure into "could not check".
-
 export function installedDistTag(version) {
   return releaseChannel(version)
 }
 
 export function latestFromDistTags(distTags, version) {
-  if (distTags === null || distTags === undefined || typeof distTags !== "object") return "could not check"
-  const value = distTags[installedDistTag(version)]
-  return typeof value === "string" && value.length > 0 ? value : "could not check"
-}
-
-function distTagsFetchScript(url, timeoutMs) {
-  return `
-const url = ${JSON.stringify(url)};
-const timeout = ${Number(timeoutMs)};
-const ac = new AbortController();
-const timer = setTimeout(() => ac.abort(), timeout);
-fetch(url, { signal: ac.signal, headers: { accept: "application/json" } })
-  .then((res) => { if (!res.ok) throw new Error(String(res.status)); return res.text(); })
-  .then((text) => { JSON.parse(text); process.stdout.write(text); })
-  .catch(() => { process.exitCode = 1; })
-  .finally(() => { clearTimeout(timer); });
-`
-}
-
-export function fetchNpmDistTagsSync(options = {}) {
-  const spawn = options.spawn ?? spawnSync
-  const url = options.url ?? NPM_DIST_TAGS_URL
-  const timeoutMs = options.timeoutMs ?? NPM_FETCH_TIMEOUT_MS
-  try {
-    const result = spawn(process.execPath, ["-e", distTagsFetchScript(url, timeoutMs)], {
-      encoding: "utf8",
-      timeout: timeoutMs + 500,
-      windowsHide: true,
-      env: process.env,
-    })
-    if (result.error || result.status !== 0 || typeof result.stdout !== "string" || result.stdout.trim() === "") return null
-    const parsed = JSON.parse(result.stdout)
-    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null
-  } catch {
-    return null
-  }
+  return channelDistTagVersion(distTags, version) ?? "could not check"
 }
 
 function readDistTags(options) {
@@ -435,6 +395,9 @@ export function runDoctor(inventory, args = [], options = {}) {
   lines.push(...staleEngineReport(options))
   lines.push(...retiredPayloadReport(options))
   lines.push(...transientMemoryReport(options))
+  const launchSpec = launchSpecDoctorLines(options.pluginRoot ?? join(packageRoot, "plugin"), options.launchSpecIo)
+  if (launchSpec.some((line) => line.startsWith("FAIL "))) failed = true
+  lines.push(...launchSpec)
   lines.push(...daemonReport(options), ...(options.computerUse ?? []), ...(options.categoryCoverage ?? []))
   if ((options.computerUse ?? []).some((line) => line.startsWith("FAIL "))) failed = true
   if (needsSetupSuggestion(inventory)) {

package/bin/lib/engine-prepare.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs"
 import { join } from "node:path"
 import { floorClaudeCodeVersion } from "./claude-code-floor.js"
 import { prepareCompileSafeEngine } from "./compile-safe-engine.js"
+import { LAUNCH_SPEC_FILENAME, normalizeLaunchSpecMode } from "./launch-spec-mode.js"
 import { prepareRpcStreamErrors } from "./rpc-stream-errors.js"
 
 // Written inside the engine tree, so reinstalling or upgrading the engine drops it with the tree.
@@ -28,6 +29,20 @@ function isPreparedFor(senpiRoot, omoVersion) {
  * A failure is reported with the reinstall command and never blocks the launch: an unprepared
  * engine still runs, only without the guards.
  */
+/**
+ * The plugin's launch spec is re-checked on every launch, not behind the engine stamp: a reinstall
+ * of omo-ai under a loose umask rewrites the plugin while the engine tree keeps its stamp (#9208).
+ * Fail-open like the engine preparation: a failure warns with the manual fix and never blocks.
+ */
+export function preparePluginLaunchSpec({ pluginRoot, report = (line) => { process.stderr.write(line) }, io = {} }) {
+  try {
+    normalizeLaunchSpecMode(pluginRoot, io)
+  } catch (error) {
+    const path = join(pluginRoot, LAUNCH_SPEC_FILENAME)
+    report(`omo: could not make ${path} private (${error.message}); task children and teams need it, run: chmod 644 ${path}\n`)
+  }
+}
+
 export function ensureEnginePrepared({ senpiRoot, omoVersion, reinstallCommand, report = (line) => { process.stderr.write(line) } }) {
   if (isPreparedFor(senpiRoot, omoVersion)) return
   try {

package/bin/lib/launch-spec-mode.js

@@ -0,0 +1,78 @@
+import { chmodSync, lstatSync, statSync } from "node:fs"
+import { userInfo } from "node:os"
+import { join } from "node:path"
+
+export const LAUNCH_SPEC_FILENAME = "daemon-launch-spec.json"
+
+// The task host refuses a spec another user could rewrite (senpi-task `rejectInsecureMode`):
+// any group/world write bit, or an owner other than the current user.
+const WRITABLE_BY_OTHERS = 0o022
+
+function currentUid() {
+  return process.getuid?.()
+}
+
+function isMissing(error) {
+  return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")
+}
+
+/**
+ * npm and bun extract package files with the installing user's umask, so a `umask 002` install
+ * leaves the spec 0664 and every task host start refuses it (#9208). Only the group/world write
+ * bits are removed, only on a regular file this user owns; a symlink is never followed, so a link
+ * (or a file owned by someone else) is left exactly as it is and the host still rejects it.
+ */
+export function normalizeLaunchSpecMode(pluginRoot, io = {}) {
+  const path = join(pluginRoot, LAUNCH_SPEC_FILENAME)
+  if ((io.platform ?? process.platform) === "win32") return { action: "skipped", path, reason: "win32" }
+  let stat
+  try {
+    stat = (io.lstat ?? lstatSync)(path)
+  } catch (error) {
+    if (isMissing(error)) return { action: "skipped", path, reason: "missing" }
+    throw error
+  }
+  if (!stat.isFile()) return { action: "left", path, reason: "not_regular_file" }
+  const uid = io.getuid === undefined ? currentUid() : io.getuid()
+  if (uid !== undefined && stat.uid !== uid) return { action: "left", path, reason: "foreign_owner" }
+  const from = stat.mode & 0o7777
+  if ((from & WRITABLE_BY_OTHERS) === 0) return { action: "unchanged", path }
+  const to = from & ~WRITABLE_BY_OTHERS
+  ;(io.chmod ?? chmodSync)(path, to)
+  return { action: "normalized", path, from, to }
+}
+
+function ownerName() {
+  try {
+    return userInfo().username
+  } catch {
+    return "$USER"
+  }
+}
+
+/**
+ * The doctor view applies the task host's own rule (the reader follows symlinks), so it reports
+ * exactly the specs the host would refuse: the ones a launch could not normalize.
+ */
+export function launchSpecDoctorLines(pluginRoot, io = {}) {
+  if ((io.platform ?? process.platform) === "win32") return []
+  const path = join(pluginRoot, LAUNCH_SPEC_FILENAME)
+  let stat
+  try {
+    stat = (io.stat ?? statSync)(path)
+  } catch (error) {
+    if (isMissing(error)) return []
+    throw error
+  }
+  if (!stat.isFile()) return []
+  const uid = io.getuid === undefined ? currentUid() : io.getuid()
+  const impact = "the task host refuses it, so process-mode task children and every team_create fail"
+  if (uid !== undefined && stat.uid !== uid) {
+    return [`FAIL launch spec: launch_spec_insecure: ${path} is not owned by you (uid ${stat.uid}); ${impact}. Fix: reinstall omo as this user, or run: sudo chown ${ownerName()} ${path}`]
+  }
+  if ((stat.mode & WRITABLE_BY_OTHERS) !== 0) {
+    const mode = (stat.mode & 0o777).toString(8)
+    return [`FAIL launch spec: launch_spec_insecure: ${path} is group/world-writable (${mode}); ${impact}. Fix: chmod 644 ${path}`]
+  }
+  return []
+}

package/bin/lib/launcher.js

@@ -6,29 +6,17 @@ 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 { ensureEnginePrepared, preparePluginLaunchSpec } from "./engine-prepare.js"
 import { migrateLegacyBunGlobalManifest } from "./legacy-bun-global-migration.js"
 import { adoptLegacyFlatState, canonicalAgentDir } from "./agent-dir.js"
 import { nearestNodeBin, packageManifest, packageRoot, readJson, releaseBanner, releaseChannel, resolveSenpi, updateTarget } from "./package-paths.js"
 import { runSelfUpdate } from "./self-update.js"
+import { isSelfUpdate } from "./update-args.js"
 import { detectHarnesses } from "./setup-detect.js"
 import { readSetupSuggestionCache, spawnSetupSuggestionRefresh } from "./setup-detect-cache.js"
 import { printSetupReport } from "./setup-report.js"
 
 const earlyCommands = new Set(["install", "remove", "list", "config", "auth", "app-server", "host"])
-const selfUpdateTargets = new Set(["self", "senpi", "omo"])
-// Updating extensions or model catalogs is the engine's job; everything else under `update`
-// would try to replace the pinned engine, so the launcher answers it instead.
-const engineUpdateTargets = new Set(["--extensions", "--models"])
-
-function isSelfUpdate(args) {
-  if (args[0] !== "update") return false
-  const rest = args.slice(1)
-  if (rest.length === 0) return true
-  if (rest.some((arg) => engineUpdateTargets.has(arg))) return false
-  return rest.every((arg) => arg.startsWith("-") || selfUpdateTargets.has(arg))
-}
-
 // Identity the engine adopts for this install: what the user sees, where state lives, which
 // environment prefix is read first, what goes on the wire, and which channel to check for
 // updates. The engine consumes this once and scrubs it, so nested engine processes are
@@ -136,6 +124,7 @@ function senpiEnvironment(senpiRoot) {
 }
 
 function preparedSenpi() {
+  preparePluginLaunchSpec({ pluginRoot: join(packageRoot, "plugin") })
   const senpi = resolveSenpi()
   ensureEnginePrepared({
     senpiRoot: senpi.packageRoot,
@@ -162,6 +151,12 @@ async function spawnSenpi(args, withExtension) {
   await spawnNode(senpi.cliPath, finalArgs, { env })
 }
 
+// Routine launch notices go straight to stderr: Bun renders every console.error line red on a
+// color terminal, which made a healthy startup look like a failure (#8442).
+function notice(line) {
+  process.stderr.write(`${line}\n`)
+}
+
 function isInteractiveDefault(args) {
   return process.stderr.isTTY === true && !args.includes("-p") && !args.includes("--print")
 }
@@ -180,7 +175,7 @@ function reportLegacyFlatAdoption() {
   }
   if (!result.adopted) return
   const moved = [...result.copied, ...result.backfilled].join(", ")
-  console.error(`omo: carried forward settings from the legacy ~/.omo layout (${moved})`)
+  notice(`omo: carried forward settings from the legacy ~/.omo layout (${moved})`)
 }
 
 /**
@@ -261,6 +256,8 @@ export async function runLauncher(args = process.argv.slice(2)) {
     return
   }
   if (command === "doctor") {
+    // Doctor is a launch too: it reports only what the launch-time preparation could not fix.
+    preparePluginLaunchSpec({ pluginRoot: join(packageRoot, "plugin") })
     const [categoryCoverage, computerUse] = args[1] === "--reap"
       ? [[], []]
       : await Promise.all([
@@ -301,9 +298,9 @@ export async function runLauncher(args = process.argv.slice(2)) {
     return
   }
   if (isInteractiveDefault(args)) {
-    console.error(releaseBanner())
+    notice(releaseBanner())
     if (process.stdout.isTTY === true && setupSuggestionForLaunch()) {
-      console.error("omo: sibling credentials detected; run `omo setup` to review them")
+      notice("omo: sibling credentials detected; run `omo setup` to review them")
     }
   }
   await spawnSenpi(args, true)

package/bin/lib/npm-dist-tags.js

@@ -0,0 +1,42 @@
+import { spawnSync } from "node:child_process"
+
+const NPM_DIST_TAGS_URL = "https://registry.npmjs.org/-/package/omo-ai/dist-tags"
+const NPM_FETCH_TIMEOUT_MS = 5000
+
+// The dist-tags of omo-ai, read by `omo doctor` for "Latest" and by `omo update` for the version it
+// installs. Doctor is called without await from the launcher and the compiled entry, so the
+// registry lookup has to finish before we print. A bounded child fetch keeps that synchronous
+// and turns any network failure into null.
+
+function distTagsFetchScript(url, timeoutMs) {
+  return `
+const url = ${JSON.stringify(url)};
+const timeout = ${Number(timeoutMs)};
+const ac = new AbortController();
+const timer = setTimeout(() => ac.abort(), timeout);
+fetch(url, { signal: ac.signal, headers: { accept: "application/json" } })
+  .then((res) => { if (!res.ok) throw new Error(String(res.status)); return res.text(); })
+  .then((text) => { JSON.parse(text); process.stdout.write(text); })
+  .catch(() => { process.exitCode = 1; })
+  .finally(() => { clearTimeout(timer); });
+`
+}
+
+export function fetchNpmDistTagsSync(options = {}) {
+  const spawn = options.spawn ?? spawnSync
+  const url = options.url ?? NPM_DIST_TAGS_URL
+  const timeoutMs = options.timeoutMs ?? NPM_FETCH_TIMEOUT_MS
+  try {
+    const result = spawn(process.execPath, ["-e", distTagsFetchScript(url, timeoutMs)], {
+      encoding: "utf8",
+      timeout: timeoutMs + 500,
+      windowsHide: true,
+      env: process.env,
+    })
+    if (result.error || result.status !== 0 || typeof result.stdout !== "string" || result.stdout.trim() === "") return null
+    const parsed = JSON.parse(result.stdout)
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null
+  } catch {
+    return null
+  }
+}

package/bin/lib/package-paths.js

@@ -20,6 +20,13 @@ export function releaseChannel(version = packageManifest().version) {
   return typeof version === "string" && version.includes("-") ? "beta" : "latest"
 }
 
+/** The version the npm dist-tag of `version`'s channel names, or undefined when the tags lack it. */
+export function channelDistTagVersion(distTags, version = packageManifest().version) {
+  if (distTags === null || distTags === undefined || typeof distTags !== "object") return undefined
+  const value = distTags[releaseChannel(version)]
+  return typeof value === "string" && value.length > 0 ? value : undefined
+}
+
 /** 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})`
@@ -38,14 +45,27 @@ function installedVersion(root) {
   }
 }
 
+/**
+ * The package-manager command that updates the install at `root`. `targetVersion` pins the exact
+ * `omo-ai@<version>` spec; without it the channel spec is installed.
+ *
+ * @param {string} [root]
+ * @param {NodeJS.Platform} [platform]
+ * @param {string} [version]
+ * @param {string} [homeDir]
+ * @param {(path: string) => boolean} [exists]
+ * @param {string} [targetVersion]
+ */
 export function updateTarget(
   root = packageRoot,
   platform = process.platform,
   version = installedVersion(root),
   homeDir = process.env.HOME || process.env.USERPROFILE || homedir(),
   exists = existsSync,
+  targetVersion = undefined,
 ) {
-  const spec = channelPackageSpec(version)
+  // A resolved target installs that exact version; without one the channel spec is the only answer.
+  const spec = targetVersion === undefined ? channelPackageSpec(version) : `omo-ai@${targetVersion}`
   const updateCwd = dirname(join(root, "package.json"))
   const normalizedRoot = updateCwd.replaceAll("\\", "/")
   const normalizedHome = homeDir.replaceAll("\\", "/").replace(/\/+$/, "")

package/bin/lib/provider-map.json

@@ -1,5 +1,5 @@
 {
-  "_comment": "Derived from @code-yeongyu/senpi 2026.9.29-3 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.29-5 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/rpc-stream-errors.js

@@ -1,8 +1,8 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs"
 import { join } from "node:path"
 
-const serialization = 'return JSON.stringify(value.type === "message_update" ? toJsonEvent(value) : value);'
-const guardedSerialization = `try {
+export const serialization = 'return JSON.stringify(value.type === "message_update" ? toJsonEvent(value) : value);'
+export const guardedSerialization = `try {
                     ${serialization}
                 } catch (error) {
                     if (!(error instanceof Error)) throw error;

package/bin/lib/self-update.js

@@ -1,12 +1,10 @@
 import { join } from "node:path"
 import { runChild } from "./child-process.js"
-import { packageManifest, readJson, resolveSenpi, updateTarget } from "./package-paths.js"
+import { fetchNpmDistTagsSync } from "./npm-dist-tags.js"
+import { channelDistTagVersion, channelPackageSpec, packageManifest, readJson, releaseChannel, resolveSenpi, updateTarget } from "./package-paths.js"
+import { isPrintOnlyUpdate, updateUsageAnswer } from "./update-args.js"
 
-const PRINT_ONLY_FLAGS = new Set(["--dry-run", "--print"])
-
-export function isPrintOnlyUpdate(args) {
-  return args.slice(1).some((arg) => PRINT_ONLY_FLAGS.has(arg))
-}
+export { isPrintOnlyUpdate }
 
 export function formatUpdateCommand(update) {
   return `omo is updated via ${update.manager}: ${update.command}`
@@ -27,16 +25,22 @@ export function formatVersionChange(before, after) {
 }
 
 /**
- * Prints and optionally runs the package-manager command `updateTarget()` resolved. `--dry-run`
- * and `--print` keep the print-only answer; anything else streams the spawn, then reports the
- * installed versions. A failed manager run exits non-zero with the same command to retry by hand.
+ * Resolves the version the running build's channel dist-tag names (the lookup `omo doctor` uses for
+ * "Latest"), then prints and optionally runs the package-manager command that installs exactly that
+ * version. `--help`/`-h` print the usage and an unknown flag exits 2, both before the registry lookup,
+ * so neither can install anything (#9207). `--dry-run` and `--print` print the resolved command only.
+ * Already on the target, it says so and installs nothing. After a manager exit 0 it re-reads the installed version: one that did not
+ * reach the target exits non-zero with the retry command, because the manager's own success does not
+ * prove the install moved (#9198). An unreachable registry falls back to the unpinned channel spec.
  * `run` defaults to `runChild` so tests inject a spawn without touching the child-process helper.
  *
  * @typedef {{ omo: string, engine: string }} InstalledVersion
  * @typedef {{ status: number | null, signal: string | null }} ChildResult
  * @typedef {{ stdio?: "inherit", windowsHide?: boolean, env?: NodeJS.ProcessEnv }} RunOptions
+ * @typedef {{ manager: string, command: string, argv: string[], env?: Record<string, string> }} UpdateTarget
  * @typedef {{
- *   update?: { manager: string, command: string, argv: string[], env?: Record<string, string> },
+ *   resolveUpdate?: (targetVersion?: string) => UpdateTarget,
+ *   fetchDistTags?: () => Record<string, unknown> | null,
  *   log?: (line: string) => void,
  *   error?: (line: string) => void,
  *   run?: (command: string, args: string[], options?: RunOptions) => Promise<ChildResult>,
@@ -48,17 +52,39 @@ export function formatVersionChange(before, after) {
  * @returns {Promise<number>}
  */
 export async function runSelfUpdate(args, options = {}) {
-  const update = options.update ?? updateTarget()
+  const resolveUpdate = options.resolveUpdate
+    ?? ((targetVersion) => updateTarget(undefined, undefined, undefined, undefined, undefined, targetVersion))
+  const fetchDistTags = options.fetchDistTags ?? fetchNpmDistTagsSync
   const log = options.log ?? ((line) => console.log(line))
   const error = options.error ?? ((line) => console.error(line))
   const run = options.run ?? runChild
   const readInstalled = options.readInstalled ?? readInstalledVersion
   const env = options.env ?? process.env
 
-  log(formatUpdateCommand(update))
-  if (isPrintOnlyUpdate(args)) return 0
+  const usage = updateUsageAnswer(args)
+  if (usage !== undefined) {
+    ;(usage.stream === "stderr" ? error : log)(usage.text)
+    return usage.exitCode
+  }
 
   const before = readInstalled()
+  const channel = releaseChannel(before.omo)
+  const target = channelDistTagVersion(fetchDistTags(), before.omo)
+  const update = resolveUpdate(target)
+
+  if (target === undefined) {
+    log(`omo: could not confirm the ${channel} omo-ai version from the npm registry; installing the unpinned ${channelPackageSpec(before.omo)}`)
+  }
+  if (isPrintOnlyUpdate(args)) {
+    log(formatUpdateCommand(update))
+    return 0
+  }
+  if (target !== undefined && target === before.omo) {
+    log(`omo ${before.omo} is up to date (omo-ai@${channel} is ${target})`)
+    return 0
+  }
+  log(formatUpdateCommand(update))
+
   const [command, ...argv] = update.argv
   let result
   try {
@@ -77,6 +103,12 @@ export async function runSelfUpdate(args, options = {}) {
     return result.status ?? 1
   }
 
-  log(formatVersionChange(before, readInstalled()))
+  const after = readInstalled()
+  if (target !== undefined && after.omo !== target) {
+    error(`omo is still ${after.omo}; ${target} is published`)
+    error(`omo: update failed; retry with: ${update.command}`)
+    return 1
+  }
+  log(formatVersionChange(before, after))
   return 0
 }

package/bin/lib/update-args.js

@@ -0,0 +1,49 @@
+const selfUpdateTargets = new Set(["self", "senpi", "omo"])
+// Updating extensions or model catalogs is the engine's job; everything else under `update`
+// would try to replace the pinned engine, so the launcher answers it instead.
+const engineUpdateTargets = new Set(["--extensions", "--models"])
+const PRINT_ONLY_FLAGS = new Set(["--dry-run", "--print"])
+const HELP_FLAGS = new Set(["--help", "-h"])
+// `--self` is the documented spelling of the bare command (docs/reference/omo-ai-publishing.md).
+const KNOWN_FLAGS = new Set([...PRINT_ONLY_FLAGS, ...HELP_FLAGS, "--self"])
+
+export const UPDATE_USAGE = `Usage: omo update [--dry-run | --print]
+
+Update omo to the newest release on its channel. The engine is pinned by omo and moves with it.
+
+Options:
+  --dry-run, --print  print the update command without running it
+  -h, --help          show this help`
+
+/**
+ * Whether `args` is a product self-update, which the launcher answers itself rather than letting
+ * the engine move its pin: bare `update`, the self/senpi/omo targets, or flags only.
+ * @param {readonly string[]} args
+ */
+export function isSelfUpdate(args) {
+  if (args[0] !== "update") return false
+  const rest = args.slice(1)
+  if (rest.length === 0) return true
+  if (rest.some((arg) => engineUpdateTargets.has(arg))) return false
+  return rest.every((arg) => arg.startsWith("-") || selfUpdateTargets.has(arg))
+}
+
+/** @param {readonly string[]} args */
+export function isPrintOnlyUpdate(args) {
+  return args.slice(1).some((arg) => PRINT_ONLY_FLAGS.has(arg))
+}
+
+/**
+ * Help and usage errors of a self-update, answered before any registry lookup or install:
+ * `--help`/`-h` print the usage (exit 0), and a flag `update` does not know is a usage error that
+ * names it (exit 2). Undefined means the arguments are a real update request (#9207).
+ * @param {readonly string[]} args
+ * @returns {{ exitCode: 0 | 2, stream: "stdout" | "stderr", text: string } | undefined}
+ */
+export function updateUsageAnswer(args) {
+  const rest = args.slice(1)
+  if (rest.some((arg) => HELP_FLAGS.has(arg))) return { exitCode: 0, stream: "stdout", text: UPDATE_USAGE }
+  const unknown = rest.find((arg) => arg.startsWith("-") && !KNOWN_FLAGS.has(arg))
+  if (unknown === undefined) return undefined
+  return { exitCode: 2, stream: "stderr", text: `omo update: unknown option ${unknown}\nRun omo update --help for usage.` }
+}

package/bin/senpi-patch.mjs

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from "node:fs"
 import { dirname, join } from "node:path"
 import { createRequire } from "node:module"
 import { fileURLToPath } from "node:url"
-import { prepareInstalledEngine, writeEnginePreparedStamp } from "./lib/engine-prepare.js"
+import { prepareInstalledEngine, preparePluginLaunchSpec, writeEnginePreparedStamp } from "./lib/engine-prepare.js"
 
 const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)))
 const require = createRequire(join(packageRoot, "package.json"))
@@ -23,5 +23,6 @@ try {
   throw new Error("omo-ai: unable to resolve the installed @code-yeongyu/senpi package", { cause: error })
 }
 
+preparePluginLaunchSpec({ pluginRoot: join(packageRoot, "plugin") })
 prepareInstalledEngine(senpiRoot)
 writeEnginePreparedStamp(senpiRoot, JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8")).version)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omo-ai",
-  "version": "5.1.2",
+  "version": "5.1.4",
   "type": "module",
   "description": "OmO Native - the standalone omo command with the OMO extension built in: bun add -g omo-ai",
   "bin": {
@@ -17,7 +17,7 @@
     "postinstall": "node bin/senpi-patch.mjs"
   },
   "dependencies": {
-    "@code-yeongyu/senpi": "2026.9.29-3"
+    "@code-yeongyu/senpi": "2026.9.29-5"
   },
   "repository": {
     "type": "git",

package/plugin/CHANGELOG.md

@@ -7,6 +7,64 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [5.1.4] - 2026-09-29
+
+### Changed
+
+OmO Native moves from senpi 2026.9.29-4 to senpi 2026.9.29-5, and the engine changes below come with it.
+
+**GPT-6.1 Sol arrives, and `deep-low` and Geeky · Normal lead with it at medium.** ([#9214](https://github.com/code-yeongyu/oh-my-openagent/issues/9214), [senpi#2390](https://github.com/code-yeongyu/senpi/issues/2390)) The engine adds `gpt-6.1-sol` and its Fast tier `gpt-6.1-sol-fast` on the OpenAI API, ChatGPT subscription, Azure, GitHub Copilot, OpenCode Zen, OpenRouter, Venice and Vercel lanes with the documented `low`..`max` efforts, and makes it the implicit default for the OpenAI and ChatGPT-subscription providers where GPT-6 Sol was. It runs on the GPT-6 system prompt, which gains the two writing rules from OpenAI's own GPT-6.1 Sol template. The default deep delegation lane now starts on `gpt-6.1-sol` (medium) from your ChatGPT subscription or the OpenAI API, then `gpt-6.1-sol-fast`, and keeps GPT-5.6 Sol (medium) and GPT-5.6 Sol Fast behind them, so GitHub Copilot, OpenCode Zen and an engine that does not list GPT-6.1 Sol yet still run the lane on GPT-5.6 Sol as before. The `geeky-normal` model profile likewise applies GPT-6.1 Sol (medium) first and GPT-5.6 Sol (medium) when 6.1 Sol is not served. The effort stays medium on every rung. The other categories and model profiles are unchanged.
+
+**A host can give each session the chat-style app prompt.** ([senpi#2377](https://github.com/code-yeongyu/senpi/issues/2377)) With `SENPI_PROMPT_SURFACE=app`, or `open_session.promptSurface: "app"` on a multi-session host, replies drop the terminal routing line and keep tool and hook feedback with the agent unless it changes what you get. Terminal sessions keep today's prompts.
+
+### Fixed
+
+**Editing a file outside a project no longer asks you to install a language server.** ([#9223](https://github.com/code-yeongyu/oh-my-openagent/issues/9223)) After an edit to OmO's own config, a scratch file in a temp folder, or any file with no project around it, the LSP check told the agent to install the missing server "in THIS repository" and to ask you first, which would have created a `package.json` in your home or temp folder, and it came back on every edit. Those files now get no install prompt, and inside a project the prompt for a missing server appears once per session instead of after every edit. Thanks to @haamsuk-collab for the report.
+
+**Kibitzer recall and quick delegation work with a single Z.ai or Xiaomi login.** ([#9202](https://github.com/code-yeongyu/oh-my-openagent/issues/9202)) The `quick` category had no Z.ai or Xiaomi model, so on a machine logged in to only one of them recall stayed off and quick tasks were unavailable. It now falls back to `glm-5.3-flash` (Z.ai) and `mimo-v2.6-flash` (Xiaomi) at low effort, after every model it already used, so machines that had a quick model keep the same one.
+
+**Engine fixes from senpi 2026.9.29-5.** Remote compaction works again on the ChatGPT subscription lane instead of silently falling back to a local summary ([senpi#2378](https://github.com/code-yeongyu/senpi/issues/2378)). A session no longer leaves an empty `.omo/` folder in the project ([senpi#2386](https://github.com/code-yeongyu/senpi/issues/2386)). RPC `get_auth_providers` reports each login method's status separately ([senpi#2384](https://github.com/code-yeongyu/senpi/issues/2384)). The embedded tree-sitter grammars load on Node again ([senpi#2032](https://github.com/code-yeongyu/senpi/issues/2032)).
+
+## [5.1.3] - 2026-09-29
+
+### Changed
+
+- OmO Native moves from senpi 2026.9.29-3 to senpi 2026.9.29-4; the engine changes below come with it.
+
+**Breaking: an untrusted project's legacy `.pi/` resources no longer load.** ([senpi#2375](https://github.com/code-yeongyu/senpi/pull/2375)) Extensions, skills, prompt templates, themes and hooks under a project's `.pi/` now follow project trust like the rest of the project config. A project whose only project resources are in `.pi/` now asks whether you trust it instead of opening as trusted. Trusted projects load them as before.
+
+**Breaking: interactive sessions no longer join a shared engine host.** ([senpi#2328](https://github.com/code-yeongyu/senpi/issues/2328)) Every interactive launch runs on its own local runtime. Extensions lose `pi.sharedHostEnabled`, and the `experimental.sharedHost` setting and the `SENPI_ENABLE_SHARED_HOST` / `SENPI_DISABLE_SHARED_HOST` variables are ignored if set. On first load `experimental.sharedHost` is removed from the global settings file.
+
+**Local sessions can pass messages and whole sessions to each other.** ([senpi#2328](https://github.com/code-yeongyu/senpi/issues/2328)) An extension can open a terminal session to other local sessions with `pi.session.registerControlEndpoint`, and each message delivered that way is admitted once and waits while you are typing. A multi-session host hands a quiet session to your terminal with `release_session`, and with `interrupt: true` it stops the running work first and returns what it took out of the queue. Host status shows each endpoint's kind, whether it answers and who owns it, and a suspended terminal no longer holds the listing for 10 seconds.
+
+**Claude answers in your language.** ([senpi#2366](https://github.com/code-yeongyu/senpi/issues/2366)) With a "reply in Korean" rule, or when you write in Korean, the routing line, the handoff block and todo labels come back in that language. The handoff labels (`Ask`, `For you`, `Now`, `Next`) stay as they are. Thanks to @floweredao for the report.
+
+**The engine installs smaller and faster.** ([senpi#2360](https://github.com/code-yeongyu/senpi/issues/2360), [senpi#2362](https://github.com/code-yeongyu/senpi/issues/2362)) senpi now declares its real dependencies instead of shipping its whole dependency tree inside the tarball, and it no longer ships sourcemaps.
+
+### Fixed
+
+**Memory recall works on a machine whose quick-category pin names only providers you are not logged into.** ([#9216](https://github.com/code-yeongyu/oh-my-openagent/issues/9216)) With `categories.quick.models` pinned to, say, OpenAI while only another provider is connected, Kibitzer started its recall judge on the pinned model, which failed at once with "No API key found", so recalled-memory nudges never arrived. Kibitzer now starts on the first connected model, your pins first and then the category's built-in chain, and when nothing is connected it shows the "Kibitzer unavailable" notice naming the providers to connect. The `task` tool still uses your pin as written.
+
+**Teams and process-mode subagents work again on installs made under `umask 002`.** ([#9208](https://github.com/code-yeongyu/oh-my-openagent/issues/9208)) With the Ubuntu default umask for private-group users, npm installed the task-host launch spec group-writable, the task host refused it, and every `team_create` failed with only "The task host is unavailable." OmO now makes that file private (0644) when it launches, never following a symlink and never touching a file another user owns. When the task host still refuses the spec, the task, the `team_create` error and `omo doctor` name the file and the fix (`chmod 644 <path>`). Reported and diagnosed by @devswha.
+
+**An npm-installed comment checker is found again, in the old and the new package layout.** ([#9180](https://github.com/code-yeongyu/oh-my-openagent/issues/9180)) The OpenCode edition's comment-checker hook looked for `@code-yeongyu/comment-checker` only in the `bin/` folder its install script used to fill, so an npm install of 0.7.1 or later (binaries under `vendor/`) was never used and the hook fell back to downloading its own copy. The hook, `omo doctor` and the LazyCodex fallback now find the binary under `vendor/` and in the per-platform packages the checker is moving to. Those packages cut its install from about 255 MiB to 51 MiB.
+
+**Agent mailbox state no longer lands in your repository.** ([#9201](https://github.com/code-yeongyu/oh-my-openagent/issues/9201)) OmO Native's thread tools kept their mailbox and receipts in `<project>/.omo/thread-tools`. They now live in the same per-project state folder as task state, outside the project. A project that already has the folder keeps using it.
+
+**A Claude `Request not allowed` error no longer strands a session on a fallback model.** ([senpi#2376](https://github.com/code-yeongyu/senpi/issues/2376)) A transient 403 from a Claude subscription is retried on the same model before the session falls back. A fallback target that answers with a billing error no longer pins the session: that provider is skipped for its cooldown, and the next turn returns to your original model with a notice saying why.
+
+**A project you trusted loads its `.agents/skills` again.** ([senpi#2371](https://github.com/code-yeongyu/senpi/issues/2371)) They appear under `/skill:` without launching with `--approve`. An untrusted project no longer picks up resources another session loaded from the same folder as trusted. Thanks to @sorenjuul for the report and the root-cause analysis.
+
+**Session files survive a failed write.** ([senpi#2328](https://github.com/code-yeongyu/senpi/issues/2328)) Opening a session saved by an older version rewrites it through a complete copy, so a full disk or an I/O error keeps the original intact. A write refused for permissions or space no longer leaves the refused entry in the session, and a prompt whose messages could not be saved reports that error. A refused delivery, a half-written first save or the release of a never-saved session no longer leaves a session stuck or ends an engine host.
+
+**Every `extension_ui_response` gets a reply.** ([senpi#2372](https://github.com/code-yeongyu/senpi/issues/2372)) A host or a terminal endpoint that settles one answers with the frame's own id, so a client can tell a delivered answer from a lost one.
+
+**The startup banner is no longer red.** ([#8442](https://github.com/code-yeongyu/oh-my-openagent/issues/8442)) Under Bun, `omo` printed its version banner, the `omo setup` credentials hint and the legacy-settings notice in the error color, so a healthy start looked like a failure. They now print without color; the text and the stream are unchanged. (#8870 by @cynkai)
+
+**`omo update` no longer reports success while leaving the old version installed.** ([#9198](https://github.com/code-yeongyu/oh-my-openagent/issues/9198)) It now looks up the version published on your channel and installs exactly that, for example `bun add -g omo-ai@5.1.2`. If you are already on it, nothing is installed. If the package manager finishes but OmO is still on the old version, `omo update` says `omo is still <old>; <new> is published`, prints the command to retry, and exits with an error. `omo update --dry-run` shows the exact command. When the npm registry can't be reached, it installs the unpinned `omo-ai` as before and tells you it could not confirm the version.
+
+**`omo update --help` shows help instead of updating.** ([#9207](https://github.com/code-yeongyu/oh-my-openagent/issues/9207), reported by @devswha) `omo update --help` and `omo update -h` used to run the install, and so did a mistyped flag. They now print what `omo update` does and its flags. A flag it doesn't know, such as `--forse`, stops with `omo update: unknown option --forse` and installs nothing. The compiled `omo` binary answers the same way.
+
 ## [5.1.2] - 2026-09-29
 
 ### Added