omo-ai 5.1.1 → 5.1.2

package/bin/lib/claude-code-floor.js

@@ -1,7 +1,10 @@
 import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs"
 import { join } from "node:path"
+import { engineDependencyDir } from "./engine-dependency.js"
 
-const claudeCodeVersionRelative = "node_modules/@earendil-works/pi-ai/dist/api/anthropic-messages.js"
+const piAiPackage = "@earendil-works/pi-ai"
+const claudeCodeVersionRelative = "dist/api/anthropic-messages.js"
+const claudeCodeVersionTarget = `${piAiPackage}/${claudeCodeVersionRelative}`
 const claudeCodeVersionPattern = /const claudeCodeVersion = "(\d+)\.(\d+)\.(\d+)";/
 // Claude Opus 5.5 rejects OAuth requests advertising Claude Code below 2.1.280 (claude_code_version_too_old).
 export const claudeCodeVersionFloor = "2.1.280"
@@ -13,11 +16,12 @@ function isBelowFloor([major, minor, patch]) {
 }
 
 function floorPiAi(senpiRoot) {
-  const path = join(senpiRoot, claudeCodeVersionRelative)
-  if (!existsSync(path)) throw new Error(`omo-ai: installed Senpi target is missing: ${claudeCodeVersionRelative}`)
+  const piAiRoot = engineDependencyDir(senpiRoot, piAiPackage)
+  const path = piAiRoot === undefined ? undefined : join(piAiRoot, claudeCodeVersionRelative)
+  if (path === undefined || !existsSync(path)) throw new Error(`omo-ai: installed Senpi target is missing: ${claudeCodeVersionTarget}`)
   const source = readFileSync(path, "utf8")
   const match = claudeCodeVersionPattern.exec(source)
-  if (match === null) throw new Error(`omo-ai: unsupported Senpi ${claudeCodeVersionRelative}`)
+  if (match === null) throw new Error(`omo-ai: unsupported Senpi ${claudeCodeVersionTarget}`)
   if (!isBelowFloor(match.slice(1).map(Number))) return
   writeFileSync(path, source.replace(claudeCodeVersionPattern, `const claudeCodeVersion = "${claudeCodeVersionFloor}";`))
 }

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 { openCodeRoutingGap, openCodeRoutingNotice, readEditionRouting } from "./setup-opencode-models.js"
 import { standaloneBinaryVersion } from "./standalone-binary.js"
 
 // Migration leftovers from the OpenCode edition, reported and never touched: another `omo` ahead of
@@ -321,16 +322,30 @@ export function formatMigrationLines({ shadowing, nativeDirectory, legacyPackage
   return lines
 }
 
+// The OpenCode edition's model settings Native does not use: the same line Native's first start
+// prints (omo-senpi config-startup), for as long as the gap exists.
+export function openCodeRoutingReport({ env, homeDir }) {
+  const path = ["omo.jsonc", "omo.json"].map((name) => join(homeDir, ".omo", name)).find((candidate) => readWholeFile(candidate) !== undefined)
+  let document = {}
+  if (path !== undefined) {
+    try {
+      document = parseJsonc(readWholeFile(path))
+    } catch {
+      return [] // The config loader reports an unreadable omo.jsonc itself.
+    }
+  }
+  const gap = openCodeRoutingGap(document, readEditionRouting({ home: homeDir, env }))
+  return gap.length === 0 ? [] : [`INFO ${openCodeRoutingNotice(gap)}`]
+}
+
 /** The doctor's migration section. `options.env` / `homeDir` / `platform` keep tests off the real machine. */
 export function migrationReport(options, restoreCommand) {
-  const environment = resolveMigrationEnvironment({
-    env: options.env ?? process.env,
-    platform: options.platform ?? process.platform,
-    homeDir: options.homeDir ?? homedir(),
-  })
+  const env = options.env ?? process.env
+  const homeDir = options.homeDir ?? homedir()
+  const environment = resolveMigrationEnvironment({ env, platform: options.platform ?? process.platform, homeDir })
   const bins = scanOmoBins(environment)
   const omoInstalls = omoInstallsOnPath(bins)
-  return formatMigrationLines({
+  return [...formatMigrationLines({
     shadowing: shadowingOmoBins(bins),
     nativeDirectory: omoInstalls[0]?.directory ?? null,
     legacyPackages: findLegacyPackages(environment),
@@ -339,5 +354,5 @@ export function migrationReport(options, restoreCommand) {
     omoInstalls,
     bunRoot: environment.bunRoot,
     standalone: options.standalone === true,
-  })
+  }), ...openCodeRoutingReport({ env, homeDir })]
 }

package/bin/lib/doctor-pi-config.js

@@ -0,0 +1,70 @@
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs"
+import { join } from "node:path"
+import { canonicalAgentDir, runtimeHome } from "./agent-dir.js"
+
+// Mirrors the engine's legacy-pi-edits check (senpi `src/legacy-pi-edits.ts`), which this package
+// cannot import synchronously: the same four files, the same `legacyPiAgentDir.copiedAt` record in
+// migrations-state.json, and the same rule: newer than the recorded copy (or, before the time was
+// recorded, than the agent copy's preserved mtime) and different in content. `~/.pi/agent` is only
+// read (#9173).
+export const PI_CONFIG_FILES = ["auth.json", "keybindings.json", "models.json", "settings.json"]
+
+function fileStat(path) {
+  try {
+    const stat = statSync(path)
+    return stat.isFile() ? stat : undefined
+  } catch (error) {
+    if (error?.code === "ENOENT" || error?.code === "ENOTDIR") return undefined
+    throw error
+  }
+}
+
+function recordedCopyTime(agentDir) {
+  let state
+  try {
+    state = JSON.parse(readFileSync(join(agentDir, "migrations-state.json"), "utf8"))
+  } catch {
+    // A missing or hand-broken state file means no recorded copy time; the rule falls back.
+    return undefined
+  }
+  const copiedAt = state?.schemaVersion === 1 ? state.legacyPiAgentDir?.copiedAt : undefined
+  return typeof copiedAt === "number" && Number.isFinite(copiedAt) ? copiedAt : undefined
+}
+
+export function findPiConfigEdits({ agentDir, homeDir }) {
+  const piAgentDir = join(homeDir, ".pi", "agent")
+  if (!existsSync(piAgentDir)) return []
+  if (existsSync(agentDir) && realpathSync(agentDir) === realpathSync(piAgentDir)) return []
+  const copiedAt = recordedCopyTime(agentDir)
+  const edits = []
+  for (const file of PI_CONFIG_FILES) {
+    const piPath = join(piAgentDir, file)
+    const agentPath = join(agentDir, file)
+    const pi = fileStat(piPath)
+    if (pi === undefined) continue
+    const agent = fileStat(agentPath)
+    if (pi.mtimeMs <= (copiedAt ?? agent?.mtimeMs ?? 0)) continue
+    if (agent !== undefined && readFileSync(piPath).equals(readFileSync(agentPath))) continue
+    edits.push({ file, piPath, agentPath })
+  }
+  return edits
+}
+
+export function formatPiConfigLines(agentDir, edits) {
+  return [
+    `INFO config dir: ${agentDir}`,
+    ...edits.map((edit) =>
+      `WARN You edited ${edit.piPath} after omo moved to ${agentDir}; omo reads ${edit.agentPath}. Copy your change there (or run: omo config import-pi ${edit.file}).`),
+  ]
+}
+
+export function piConfigReport(options = {}) {
+  const env = options.env ?? process.env
+  const agentDir = options.agentDir ?? canonicalAgentDir(env)
+  const homeDir = options.homeDir ?? runtimeHome(env)
+  try {
+    return formatPiConfigLines(agentDir, findPiConfigEdits({ agentDir, homeDir }))
+  } catch (error) {
+    return [`INFO config dir: ${agentDir}`, `WARN could not check ${join(homeDir, ".pi", "agent")} for config edits: ${error.message}`]
+  }
+}

package/bin/lib/doctor.js

@@ -6,6 +6,7 @@ import { canonicalAgentDir } from "./agent-dir.js"
 import { packageManifest, packageRoot, readJson, releaseChannel, resolveSenpi, updateTarget } from "./package-paths.js"
 import { daemonReportLines } from "./daemon.js"
 import { migrationReport } from "./doctor-migration.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"
@@ -430,6 +431,7 @@ export function runDoctor(inventory, args = [], options = {}) {
   lines.push(`INFO Update: ${updateTarget().command}`)
   lines.push(...migrationReport(options, updateTarget().command))
   lines.push(...warningsForSettings())
+  lines.push(...piConfigReport({ env: options.env, homeDir: options.homeDir }))
   lines.push(...staleEngineReport(options))
   lines.push(...retiredPayloadReport(options))
   lines.push(...transientMemoryReport(options))

package/bin/lib/engine-dependency.js

@@ -0,0 +1,23 @@
+import { realpathSync, statSync } from "node:fs"
+import { basename, dirname, join } from "node:path"
+
+/**
+ * The directory of `name` as the engine installed at `senpiRoot` resolves it: Node's
+ * node_modules walk from senpi's real path. That one walk covers every install shape - a
+ * bundled senpi keeps the dependency in its own `node_modules`, npm hoists it beside senpi,
+ * and bun's isolated store links it beside senpi's real path in `.bun/<key>/node_modules` -
+ * so no caller may assume where the dependency lives. Returns undefined when nothing on the
+ * walk provides `name`.
+ */
+export function engineDependencyDir(senpiRoot, name) {
+  let current = realpathSync(senpiRoot)
+  while (true) {
+    if (basename(current) !== "node_modules") {
+      const candidate = join(current, "node_modules", name)
+      if (statSync(candidate, { throwIfNoEntry: false })?.isDirectory()) return candidate
+    }
+    const parent = dirname(current)
+    if (parent === current) return undefined
+    current = parent
+  }
+}

package/bin/lib/engine-models.js

@@ -11,13 +11,16 @@ import { existsSync, readFileSync } from "node:fs"
 import { join } from "node:path"
 import { pathToFileURL } from "node:url"
 import { parseJsonc } from "./jsonc.js"
+import { engineDependencyDir } from "./engine-dependency.js"
 import { resolveSenpi } from "./package-paths.js"
 
 // The same module the engine's model-runtime.js composes its builtins from
-// (`builtinProviderCatalog.builtinProviders()`), at the path claude-code-floor.js already relies on.
+// (`builtinProviderCatalog.builtinProviders()`), in the pi-ai the engine itself resolves.
 async function builtinCatalog() {
   const { packageRoot } = resolveSenpi()
-  const path = join(packageRoot, "node_modules", "@earendil-works", "pi-ai", "dist", "providers", "all.js")
+  const piAiRoot = engineDependencyDir(packageRoot, "@earendil-works/pi-ai")
+  if (piAiRoot === undefined) throw new Error(`the engine model catalog is missing: @earendil-works/pi-ai is not resolvable from ${packageRoot}`)
+  const path = join(piAiRoot, "dist", "providers", "all.js")
   if (!existsSync(path)) throw new Error(`the engine model catalog is missing at ${path}`)
   return (await import(pathToFileURL(path).href)).builtinProviders()
 }

package/bin/lib/provider-map.json

@@ -1,5 +1,5 @@
 {
-  "_comment": "Derived from @code-yeongyu/senpi 2026.9.29 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-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.",
   "builtinProviderIds": [
     "alibaba-token-plan",
     "amazon-bedrock",

package/bin/lib/setup-opencode-models.d.ts

@@ -0,0 +1,53 @@
+// Types for setup-opencode-models.js, which omo-senpi's config-startup imports across the package
+// boundary: omo-ai ships this module as plain JS, so it is the single source of the mapping.
+
+export type ModelRegistry = {
+  readonly models: ReadonlyMap<string, ReadonlySet<string>>
+  readonly dynamic: ReadonlySet<string>
+}
+
+export type EditionRouting = {
+  readonly agents: Readonly<Record<string, unknown>>
+  readonly categories: Readonly<Record<string, unknown>>
+  readonly notices: readonly string[]
+}
+
+export type ConvertedChoice = {
+  readonly name: string
+  readonly entry: Readonly<Record<string, unknown>>
+  readonly from: string
+}
+
+export const NATIVE_AGENT_NAMES: readonly string[]
+
+export function readEditionRouting(options: { home: string; env: Readonly<Record<string, string | undefined>> }): EditionRouting
+
+export function readModelChoices(options: {
+  home: string
+  env: Readonly<Record<string, string | undefined>>
+  opencodeBlock: unknown
+}): Record<string, unknown>
+
+export function hasModelChoices(raw: unknown): boolean
+
+export function translateModelRef(
+  raw: unknown,
+  context: { registry?: ModelRegistry; oauthProviders: ReadonlySet<string> },
+): { ref?: string; provider?: string; modelId?: string; reason?: string }
+
+export function convertModelChoices(
+  raw: unknown,
+  registry: ModelRegistry,
+  oauthProviders?: ReadonlySet<string>,
+): {
+  defaultModel?: { source: string; provider: string; modelId: string; ref: string }
+  categories: readonly ConvertedChoice[]
+  agents: readonly ConvertedChoice[]
+  dropped: readonly string[]
+}
+
+export function nativeRoutingLine(section: string, name: string, value: Readonly<Record<string, unknown>>): string
+
+export function openCodeRoutingGap(document: unknown, edition: EditionRouting): readonly string[]
+
+export function openCodeRoutingNotice(lines: readonly string[]): string

package/bin/lib/setup-opencode-models.js

@@ -4,10 +4,14 @@
  * converts each into what the native harness reads. Provider ids go through provider-map.json, the
  * table the credential stage uses, and every provider/model is checked against the engine's model
  * list; what does not resolve is returned with its reason, never converted. Read-only.
+ *
+ * Native's startup migration (omo-senpi config-startup) runs the same conversion without the
+ * engine's model list through `openCodeRoutingGap`, so both paths map names and providers alike.
  */
 
-import { existsSync, readdirSync, readFileSync } from "node:fs"
+import { existsSync, readdirSync } from "node:fs"
 import { isAbsolute, join, relative, resolve } from "node:path"
+import providerMap from "./provider-map.json" with { type: "json" }
 import { opencodeConfigSources, readOpencodeConfig } from "./setup-opencode-assets.js"
 
 // The OpenCode edition's legacy plugin files, highest precedence first, as its config migration
@@ -29,6 +33,9 @@ export const NATIVE_AGENT_NAMES = [
 // OpenCode's own primary agents: the native main session has no per-mode agent, it runs the default model.
 const OPENCODE_PRIMARY_AGENTS = new Set(["build", "plan"])
 
+// The OpenCode edition's plan agents, keyed to the native agent that does the same job.
+const AGENT_ALIASES = { metis: "plan-consultant", momus: "plan-reviewer" }
+
 // omo-config-core schema/legacy-category-names.ts: the loader renames these and reports it.
 const CATEGORY_ALIASES = { deep: "deep-low" }
 
@@ -44,10 +51,6 @@ function record(value) {
   return isPlainObject(value) ? value : {}
 }
 
-function readProviderMap() {
-  return JSON.parse(readFileSync(new URL("./provider-map.json", import.meta.url), "utf8"))
-}
-
 // The first start of any current harness runs the config unification migration, which keeps none
 // of a legacy file's categories or agents and moves the file to
 // `~/.omo/migration-backup-<timestamp>-opencode-config/<path relative to home>`
@@ -69,12 +72,11 @@ function editionFile(path, home, notices) {
 }
 
 /**
- * The raw choices, before any translation. `opencodeBlock` is the `[opencode]` block of the user's
- * omo.json[c]: the unification migration's target, so an entry there wins over the legacy files.
+ * The OpenCode edition's own routing (`agents`, `categories`) from its legacy plugin files, or the
+ * migration backups the unification migration moved them into.
  */
-export function readModelChoices({ home, env, opencodeBlock }) {
+export function readEditionRouting({ home, env }) {
   const notices = []
-  const opencode = readOpencodeConfig(opencodeConfigSources(home, env).files, "model choices", notices)
   const globalDir = join(env.XDG_CONFIG_HOME || join(home, ".config"), "opencode")
   const explicitDir = env.OPENCODE_CONFIG_DIR?.trim()
   const directories = explicitDir ? [resolve(explicitDir), globalDir] : [globalDir]
@@ -83,14 +85,31 @@ export function readModelChoices({ home, env, opencodeBlock }) {
     .flatMap((directory) => EDITION_FILES.map((name) => editionFile(join(directory, name), home, notices)))
     .reverse()
   const edition = readOpencodeConfig(legacyFiles, "model choices", notices)
-  const block = record(opencodeBlock)
+  return { agents: record(edition.agents), categories: record(edition.categories), notices }
+}
+
+/**
+ * The raw choices, before any translation. `opencodeBlock` is the `[opencode]` block of the user's
+ * omo.json[c]: the unification migration's target, so an entry there wins over the legacy files.
+ */
+export function readModelChoices({ home, env, opencodeBlock }) {
+  const notices = []
+  const opencode = readOpencodeConfig(opencodeConfigSources(home, env).files, "model choices", notices)
+  const edition = readEditionRouting({ home, env })
   return {
     model: typeof opencode.model === "string" ? opencode.model : undefined,
     smallModel: typeof opencode.small_model === "string" ? opencode.small_model : undefined,
     opencodeAgents: record(opencode.agent),
-    categories: { ...record(edition.categories), ...record(block.categories) },
-    agents: { ...record(edition.agents), ...record(block.agents) },
-    notices,
+    ...editionChoices(edition, opencodeBlock),
+    notices: [...notices, ...edition.notices],
+  }
+}
+
+function editionChoices(edition, opencodeBlock) {
+  const block = record(opencodeBlock)
+  return {
+    categories: { ...edition.categories, ...record(block.categories) },
+    agents: { ...edition.agents, ...record(block.agents) },
   }
 }
 
@@ -104,12 +123,12 @@ export function hasModelChoices(raw) {
 }
 
 function engineProvider(provider, modelId, context) {
-  const { providerMap, oauthProviders, registry } = context
+  const { oauthProviders, registry } = context
   // A provider opencode signed in to with OAuth (`openai` through a ChatGPT plan) is served here by
   // the provider the credential stage says to `/login` to (provider-map.json `oauthLogins`), not by
   // the same id, which would need an API key the user never had.
   const login = oauthProviders.has(provider) && Object.hasOwn(providerMap.oauthLogins, provider) ? providerMap.oauthLogins[provider] : undefined
-  if (login !== undefined && registry.models.get(login)?.has(modelId)) return login
+  if (login !== undefined && registry?.models.get(login)?.has(modelId)) return login
   if (providerMap.builtinProviderIds.includes(provider)) return provider
   return providerMap.providers[provider] ?? provider
 }
@@ -125,20 +144,30 @@ function splitSuffix(text) {
   return { selector: text.slice(0, colon), suffix: `:${token}` }
 }
 
-/** `{ ref, provider, modelId }` for a model string the engine serves, else `{ reason }`. */
+/**
+ * `{ ref, provider, modelId }` for a model string the engine serves, else `{ reason }`. Without a
+ * `context.registry` (Native startup, which has no engine model list) only the provider is checked,
+ * against the engine's builtin providers.
+ */
 export function translateModelRef(raw, context) {
   if (typeof raw !== "string" || raw.trim() === "") return { reason: "not a model string" }
   const { selector, suffix } = splitSuffix(raw.trim())
   const slash = selector.indexOf("/")
+  const { registry } = context
   if (slash <= 0) {
     // A bare id is matched against every provider by the native resolver, so any provider serving it will do.
-    const served = [...context.registry.models.values()].some((ids) => ids.has(selector))
+    const served = registry === undefined || [...registry.models.values()].some((ids) => ids.has(selector))
     return served ? { ref: `${selector}${suffix}`, modelId: selector } : { reason: `no omo provider serves a model named ${selector}` }
   }
   const source = selector.slice(0, slash)
   const modelId = selector.slice(slash + 1)
   const provider = engineProvider(source, modelId, context)
-  const ids = context.registry.models.get(provider)
+  if (registry === undefined) {
+    return providerMap.builtinProviderIds.includes(provider)
+      ? { ref: `${provider}/${modelId}${suffix}`, provider, modelId }
+      : { reason: `provider ${source} is not one omo serves or was carried over` }
+  }
+  const ids = registry.models.get(provider)
   if (ids === undefined) return { reason: `provider ${source} is not one omo serves or was carried over` }
   if (!ids.has(modelId)) {
     return {
@@ -180,10 +209,10 @@ function chainItem(item, take) {
  * OpenCode edition tried them in. Undefined when the entry named models and none of them resolve:
  * its tuning alone would retune the builtin chain the user had replaced.
  */
-function convertEntry(label, entry, context, dropped) {
+function convertEntry(label, entry, context, dropped, target) {
   const take = (raw) => {
     const result = translateModelRef(raw, context)
-    if (result.reason !== undefined) dropped.push(`${label} model ${String(raw)}: ${result.reason}`)
+    if (result.reason !== undefined) dropped.push({ text: `${label} model ${String(raw)}: ${result.reason}`, target })
     return result.ref
   }
   const folded = !Array.isArray(entry.models) && entry.fallback_models !== undefined
@@ -208,17 +237,31 @@ function convertAgents(raw, context, dropped) {
   for (const [origin, entries] of [["opencode agent", raw.opencodeAgents], ["agent", raw.agents]]) {
     for (const [name, entry] of Object.entries(entries)) {
       if (!hasModelChoice(entry)) continue
-      if (!native.has(name)) {
+      const target = Object.hasOwn(AGENT_ALIASES, name) ? AGENT_ALIASES[name] : name
+      // A native name beside its alias in the same source wins, as categories resolve the pair.
+      if (target !== name && Object.hasOwn(entries, target) && hasModelChoice(entries[target])) continue
+      if (!native.has(target)) {
         dropped.push(OPENCODE_PRIMARY_AGENTS.has(name) && origin === "opencode agent"
-          ? `${origin} ${name}: the OpenCode primary agent; omo's main session runs the default model instead`
-          : `${origin} ${name}: omo has no agent of that name (its agents: ${NATIVE_AGENT_NAMES.join(", ")}); route that work through a category instead`)
+          ? { text: `${origin} ${name}: the OpenCode primary agent; omo's main session runs the default model instead` }
+          : {
+            text: `${origin} ${name}: omo has no agent of that name (its agents: ${NATIVE_AGENT_NAMES.join(", ")}); route that work through a category instead`,
+            target: { section: "categories", name: "<category>", model: firstModel(entry, context) },
+          })
         continue
       }
-      const converted = convertEntry(`${origin} ${name}`, entry, context, dropped)
-      if (converted !== undefined) agents.set(name, converted)
+      const converted = convertEntry(`${origin} ${name}`, entry, context, dropped, { section: "agents", name: target })
+      if (converted !== undefined) agents.set(target, { entry: converted, from: name })
     }
   }
-  return [...agents].map(([name, entry]) => ({ name, entry })).sort((left, right) => left.name.localeCompare(right.name))
+  return [...agents].map(([name, { entry, from }]) => ({ name, entry, from })).sort((left, right) => left.name.localeCompare(right.name))
+}
+
+// The model an unmappable agent named, as the native harness would spell it when it can.
+function firstModel(entry, context) {
+  const raw = entry.model ?? [entry.models, entry.fallback_models].flat().find((item) => item !== undefined)
+  const text = isPlainObject(raw) ? raw.model : raw
+  if (typeof text !== "string") return undefined
+  return translateModelRef(text, context).ref ?? text
 }
 
 function convertCategories(raw, context, dropped) {
@@ -228,21 +271,21 @@ function convertCategories(raw, context, dropped) {
     const target = Object.hasOwn(CATEGORY_ALIASES, name) ? CATEGORY_ALIASES[name] : name
     // A canonical key beside its retired alias wins, as the loader resolves the pair.
     if (target !== name && Object.hasOwn(raw.categories, target)) continue
-    const converted = convertEntry(`category ${name}`, entry, context, dropped)
-    if (converted !== undefined) categories.set(target, converted)
+    const converted = convertEntry(`category ${name}`, entry, context, dropped, { section: "categories", name: target })
+    if (converted !== undefined) categories.set(target, { entry: converted, from: name })
   }
-  return [...categories].map(([name, entry]) => ({ name, entry })).sort((left, right) => left.name.localeCompare(right.name))
+  return [...categories].map(([name, { entry, from }]) => ({ name, entry, from })).sort((left, right) => left.name.localeCompare(right.name))
 }
 
 function convertDefault(model, context, dropped) {
   if (model === undefined) return undefined
   const result = translateModelRef(model, context)
   if (result.reason !== undefined) {
-    dropped.push(`default model ${model}: ${result.reason}`)
+    dropped.push({ text: `default model ${model}: ${result.reason}` })
     return undefined
   }
   if (result.provider === undefined) {
-    dropped.push(`default model ${model}: names no provider, and omo's default model needs one`)
+    dropped.push({ text: `default model ${model}: names no provider, and omo's default model needs one` })
     return undefined
   }
   return { source: model, provider: result.provider, modelId: result.modelId, ref: `${result.provider}/${result.modelId}` }
@@ -253,11 +296,55 @@ function convertDefault(model, context, dropped) {
  * `oauthProviders` are the opencode provider ids whose opencode credential is an OAuth login.
  */
 export function convertModelChoices(raw, registry, oauthProviders = new Set()) {
-  const context = { registry, providerMap: readProviderMap(), oauthProviders }
+  const context = { registry, oauthProviders }
   const dropped = []
   const defaultModel = convertDefault(raw.model, context, dropped)
-  if (raw.smallModel !== undefined) dropped.push(`small_model ${raw.smallModel}: omo has no small-model setting`)
+  if (raw.smallModel !== undefined) dropped.push({ text: `small_model ${raw.smallModel}: omo has no small-model setting` })
   const categories = convertCategories(raw, context, dropped)
   const agents = convertAgents(raw, context, dropped)
-  return { defaultModel, categories, agents, dropped }
+  return { defaultModel, categories, agents, dropped: dropped.map((item) => item.text) }
+}
+
+// omo-config-core loader/resolution.ts folds a legacy `[senpi]` block under `[native]`.
+const NATIVE_BLOCKS = ["[senpi]", "[native]"]
+
+/** The omo.jsonc member that sets `value` for `section.name` in the native harness. */
+export function nativeRoutingLine(section, name, value) {
+  const members = Object.entries(value).map(([key, member]) => `"${key}": ${JSON.stringify(member)}`).join(", ")
+  return `"[native]": { "${section}": { "${name}": { ${members} } } }`
+}
+
+/**
+ * The OpenCode edition's model settings (`edition`: readEditionRouting, overlaid by `document`'s
+ * `[opencode]` block) that the native harness of `document` (a user omo.json[c]) does not use,
+ * one line each with the omo.jsonc member that would set it natively. The legacy migration never
+ * copies agents or categories (#7270), and `omo setup` carries them only with the user's consent, so
+ * this only reports: Native's startup notice and `omo doctor` print these lines. Names and providers
+ * convert as setup converts them, without the engine's model list; a key the native view (shared
+ * base, `[senpi]`, `[native]`) already sets is the user's and is not reported.
+ */
+export function openCodeRoutingGap(document, edition) {
+  const raw = { opencodeAgents: {}, ...editionChoices(edition, record(document)["[opencode]"]) }
+  const context = { registry: undefined, oauthProviders: new Set() }
+  const dropped = []
+  const converted = { categories: convertCategories(raw, context, dropped), agents: convertAgents(raw, context, dropped) }
+  const carriable = ["agents", "categories"].flatMap((section) => converted[section]
+    .filter(({ name }) => !isConfigured(document, section, name))
+    .map(({ name, entry, from }) => `${section === "agents" ? "agent" : "category"} ${from}: add ${nativeRoutingLine(section, name, entry)}`))
+  const unmapped = dropped
+    .filter(({ target }) => target === undefined || !isConfigured(document, target.section, target.name))
+    .map(({ text, target }) => target === undefined
+      ? text
+      : `${text}: add ${nativeRoutingLine(target.section, target.name, { model: target.model ?? "<provider>/<model>" })}`)
+  return [...carriable, ...unmapped]
+}
+
+/** The one-line lead of the report, for `lines` from openCodeRoutingGap. */
+export function openCodeRoutingNotice(lines) {
+  return `OpenCode edition model settings Native does not use; run omo setup to carry them over, or set them in omo.jsonc: ${lines.join("; ")}`
+}
+
+function isConfigured(document, section, name) {
+  return [record(document)[section], ...NATIVE_BLOCKS.map((key) => record(record(document)[key])[section])]
+    .some((entries) => Object.hasOwn(record(entries), name))
 }

package/package.json

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

package/plugin/CHANGELOG.md

@@ -7,6 +7,66 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [5.1.2] - 2026-09-29
+
+### Added
+
+**A one-line installer at get.omo.dev.** ([#9166](https://github.com/code-yeongyu/oh-my-openagent/issues/9166)) `curl -fsSL https://get.omo.dev/install.sh | bash` on macOS and Linux, or `irm https://get.omo.dev/install.ps1 | iex` in Windows PowerShell, installs the native `omo` binary for your OS and CPU into `~/.local/bin`, after checking it against the release `SHA256SUMS`. When get.omo.dev is unreachable it falls back to the npm registry and GitHub Releases. `bun add -g omo-ai` keeps working. omo.dev now shows the command for your OS and has an install page at `/docs/install` ([#9177](https://github.com/code-yeongyu/oh-my-openagent/issues/9177)).
+
+**`web_search` can use your own SearXNG.** ([senpi#2339](https://github.com/code-yeongyu/senpi/issues/2339)) Add `{ "provider": "searxng", "baseUrl": "http://localhost:8888" }` to `websearch.json`.
+
+### Changed
+
+**An unknown slash command no longer reaches the model by accident.** ([senpi#2348](https://github.com/code-yeongyu/senpi/issues/2348)) A typo like `/ulw-exec` goes back into the editor with a `Did you mean /skill:ulw-execute?` hint instead of being sent as a prompt. A second Enter on the unchanged text sends it as a normal message, and Esc keeps editing.
+
+**Moving from the OpenCode edition, OmO Native tells you which model choices it ignores.** ([#9147](https://github.com/code-yeongyu/oh-my-openagent/issues/9147), [#6794](https://github.com/code-yeongyu/oh-my-openagent/issues/6794)) On its first start, Native lists each agent and category model from your OpenCode edition settings that it ignores, with the `omo setup` step and the `omo.jsonc` key that carries it over. `omo setup` itself now carries the edition's `metis` and `momus` models over to `plan-consultant` and `plan-reviewer`.
+
+**Hosted web search runs on the provider's cheaper search model.** ([senpi#2340](https://github.com/code-yeongyu/senpi/issues/2340)) On the same login, for example `claude-haiku-4-5` on Claude routes, when your model list shows it at a lower price than the session model. If it fails or finds nothing, the search retries on the session model. `"nativeModel": "session"` in `websearch.json` restores the old behavior.
+
+**Without a `websearch.json`, `web_search` tries more than DuckDuckGo.** ([senpi#2339](https://github.com/code-yeongyu/senpi/issues/2339)) It now tries DuckDuckGo, Exa, Startpage, Mojeek, Ecosia and Google in turn and pauses an engine that blocks it, so your queries may reach these services. List only the providers you want in `websearch.json` to keep them away from the rest.
+
+**Remote MCP servers declared by a skill no longer receive your `bearerTokenEnv` token.** ([senpi#2345](https://github.com/code-yeongyu/senpi/issues/2345)) The skill picks the server's URL, so declare that server in your own `mcp.json` to keep its auth. Stdio servers from skills you installed now expand `${VAR}` the way your own `mcp.json` does.
+
+### Fixed
+
+**A running session survives `omo update`.** ([senpi#2358](https://github.com/code-yeongyu/senpi/issues/2358)) `omo update` and `bun install -g` replace the installed package, and a session started earlier used to fail every later request with `Cannot find module './<chunk>-<hash>.js'` until you restarted it. Each launch now runs from its own copy of the engine.
+
+**Config you edit in `~/.pi/agent` is no longer silently ignored.** ([#9173](https://github.com/code-yeongyu/oh-my-openagent/issues/9173)) After OmO copied `~/.pi/agent` to `~/.omo/agent`, edits to the old copy had no effect. The next start now warns once per edited file and names the file OmO reads, `omo doctor` lists the same files, and `omo config import-pi <file>` copies the edit over.
+
+**`omo doctor` no longer fails its computer-use check on every OS.** ([#9193](https://github.com/code-yeongyu/oh-my-openagent/issues/9193)) 5.1.1 shipped without an asset the check reads, so it always reported `ENOENT` for `assets.generated.json`.
+
+**A finished task child no longer stays "running" after its parent's host dies.** ([#9183](https://github.com/code-yeongyu/oh-my-openagent/issues/9183)) The child's record kept its dead owner, so Desktop showed a working agent that no longer existed and task status and DAG waits kept waiting on it.
+
+**Scrolling on X11 delivers every wheel click.** ([#9136](https://github.com/code-yeongyu/oh-my-openagent/issues/9136)) A foreground scroll from computer use sometimes dropped clicks and still reported success.
+
+**Bedrock accepts tool schemas with a root `anyOf`, `oneOf` or `allOf`.** ([senpi#1947](https://github.com/code-yeongyu/senpi/issues/1947)) It also accepts schemas without an object type, which it used to reject.
+
+**Memory reflection works when your only provider comes from an extension.** ([#9175](https://github.com/code-yeongyu/oh-my-openagent/issues/9175)) If that provider disappears you get one notice instead of the same failure on every run.
+
+**Cursor runs each tool call once.** ([senpi#2334](https://github.com/code-yeongyu/senpi/issues/2334)) It used to run every call a second time, and the replayed write could undo a file fix.
+
+**A resumed Claude conversation keeps its resume point.** ([senpi#1972](https://github.com/code-yeongyu/senpi/issues/1972)) When a monitor or goal starts the first turn on restore, the conversation no longer resends its whole history.
+
+**In headless runs, a late Kibitzer verdict no longer replaces the final answer.** ([#9158](https://github.com/code-yeongyu/oh-my-openagent/pull/9158)) It used to add a turn after the answer that ended in `NO_REPLY`.
+
+**An MCP server that changes its tool list mid-session gets the new list registered.** ([senpi#2188](https://github.com/code-yeongyu/senpi/issues/2188)) Added tools now show up and removed ones stay gone.
+
+**Native OpenAI requests with hosted web search no longer fail every turn with `Tool choice 'web_search' not found in 'tools' parameter`.** ([senpi#2234](https://github.com/code-yeongyu/senpi/issues/2234))
+
+**Web search through OpenAI and xAI lists only pages the search returned.** ([senpi#2337](https://github.com/code-yeongyu/senpi/issues/2337)) Links the model wrote on its own are no longer counted as sources.
+
+**A rejected OpenAI Responses WebSocket request shows the provider's message.** ([senpi#2235](https://github.com/code-yeongyu/senpi/issues/2235)) It used to show `Error Code undefined: undefined`.
+
+**Claude subscription sessions keep the field descriptions in custom tool schemas.** ([senpi#2145](https://github.com/code-yeongyu/senpi/issues/2145)) Claude no longer wastes a call on a missing required field.
+
+**The OpenAI-compatible adapter merges back-to-back user messages for non-OpenAI hosts.** ([senpi#2120](https://github.com/code-yeongyu/senpi/issues/2120)) Direct OpenAI requests are unchanged.
+
+**Extensions that depend on sloppy-mode CommonJS packages load again under Bun.** ([senpi#1841](https://github.com/code-yeongyu/senpi/issues/1841))
+
+**Picking a skill that needs input from the slash menu now waits for you to type it.** ([#9168](https://github.com/code-yeongyu/oh-my-openagent/issues/9168)) On OmO Native, choosing `/ulw-execute`, `/ulw-plan`, `/ulw-loop`, `/ulw-research`, `/mass-ulw`, `/hyperplan`, `/init-deep`, `/refactor` or `/remove-ai-slops` from the slash menu with Enter sent it right away with nothing after it, so the skill started without the plan name, request or goal it works on. These skills now declare what they take, and Enter leaves `/ulw-execute ` (or `/skill:ulw-execute `) in the input with the hint shown in the menu; type the arguments and press Enter again to send. Skills that take no input still run on one Enter. The waiting half needs the engine release that reads the hint (code-yeongyu/senpi#2258); until OmO adopts it, the menu behaves as before.
+
+**Your own `computer-use` skill no longer opens every session with a "Skill conflicts" warning.** ([#9160](https://github.com/code-yeongyu/oh-my-openagent/issues/9160)) With computer use on, OmO Native added its built-in `computer-use` skill on every start, even when you already had a skill of that name (Orca CLI ships one), so each session opened with a collision box. The built-in skill now steps aside for a same-name user, project or package skill, which is the one that loads, and `/computer status` says so in one line. The same applies to the `x-search` skill. `disabled_skills` now hides both the way it hides the bundled skills; the `computer` and `x_search` tools stay available either way.
+
 ## [5.1.1] - 2026-09-29
 
 ### Changed