omo-ai 5.1.0 → 5.1.2

package/bin/lib/daemon.js

@@ -1,45 +1,53 @@
 import { existsSync, readFileSync } from "node:fs"
 import { join } from "node:path"
+import {
+  parseEngineLine,
+  parseStoreArgs,
+  hostCommandEnvironment,
+  runGc,
+  runHandoff,
+  runStatus,
+  runStopAll,
+} from "./daemon-operations.js"
+import { runRollbackPrepare } from "./daemon-rollback.js"
+import { attachLaunchArgs, blockingPause, DAEMON_EXIT, readTimeoutSeconds } from "./daemon-args.js"
+
+export { DAEMON_EXIT } from "./daemon-args.js"
+export { daemonReportLines } from "./daemon-doctor-report.js"
 
 /**
- * `omo daemon` - the operator's view of the one machine-wide engine host.
+ * `omo daemon` - the operator's view of every engine host in one agent dir: the operator daemon on
+ * `rpc.sock` (the only endpoint `run` and `attach` ensure), each session's task host (`p-*`), each
+ * Desktop thread host (`i-*`), and any other endpoint the engine enumerates. `status`, `gc`,
+ * `handoff`, `stop --all` and `rollback-prepare` cover all of them.
  *
- * Everything that decides WHO serves the socket lives in the engine (`senpi host`): probing an
+ * Everything that decides WHO serves a socket lives in the engine (`senpi host`): probing an
  * existing host, comparing build ordinals, handing a generation over, refusing when the two sides
  * cannot agree. This wrapper owns three much smaller things, and deliberately nothing else:
  * omo's launch spec is the argv source, omo.json is where the policy comes from, and the caller
  * gets an exit code it can branch on without reading prose.
  */
 
-const SUBCOMMANDS = new Set(["run", "attach", "status", "stop", "handoff"])
-/** Flags this wrapper consumes itself; anything else after `attach` belongs to the launch. */
-const DAEMON_FLAGS = new Set(["--json", "--no-upgrade", "--persistent", "--foreground", "--include-workers", "--drain"])
+const SUBCOMMANDS = new Set(["run", "attach", "status", "stop", "handoff", "gc", "rollback-prepare"])
 /** The subcommands that can bring a host into existence, and therefore need omo's argv source. */
 const NEEDS_SPEC = new Set(["run", "attach", "handoff"])
 
-/** A named code per outcome, so a script never has to parse the message to know what happened. */
-export const DAEMON_EXIT = {
-  ok: 0,
-  usage: 2,
-  notRunning: 3,
-  unsupported: 4,
-  engineRefused: 5,
-}
-
 const USAGE = [
-  "usage: omo daemon <run|attach|status|stop|handoff> [options]",
+  "usage: omo daemon <run|attach|status|stop|handoff|gc|rollback-prepare> [options]",
   "",
   "  run       ensure a daemon is serving this agent dir (start, reuse, or hand off)",
   "  attach    print the environment a child needs to reach the daemon",
   "  status    report who is serving and which sessions exist",
   "  stop      end the daemon; --drain lets in-flight work finish first",
   "  handoff   hand the socket to this build, keeping live sessions",
+  "  gc        remove dead endpoint state; --prune-store-index drops missing store paths",
+  "  rollback-prepare migrate retained task records back to rpc.sock before downgrading",
   "",
   "  --json            print the engine's JSON line instead of a summary",
   "  --no-upgrade      never hand off, even from an older build",
-  "  --persistent      outlive the process that started it",
-  "  --foreground      run the host in this process instead of detaching",
   "  --include-workers include subagent sessions in status",
+  "  --all             apply stop to every discovered endpoint",
+  "  --wait            with stop --drain --all, wait for generations and claims to end",
 ].join("\n")
 
 /**
@@ -71,32 +79,16 @@ function readConfig(agentDir) {
  */
 const ENGINE_SUBCOMMAND = { run: "ensure", attach: "ensure", status: "status", stop: "stop", handoff: "handoff" }
 
-function buildArgs(subcommand, args, { specPath, policy, config }) {
+function buildArgs(subcommand, args, { specPath, policy }) {
   const engineArgs = ["host", ENGINE_SUBCOMMAND[subcommand], "--json"]
   if (subcommand === "run" || subcommand === "attach" || subcommand === "handoff") {
     engineArgs.push("--launch-spec", specPath, "--policy", policy)
-    const idleExitMs = config?.task?.host_idle_exit_ms
-    if (typeof idleExitMs === "number" && Number.isFinite(idleExitMs)) {
-      engineArgs.push("--idle-exit-ms", String(Math.trunc(idleExitMs)))
-    }
-    if (args.includes("--persistent")) engineArgs.push("--persistent")
-    if (args.includes("--foreground")) engineArgs.push("--foreground")
   }
   if (subcommand === "stop" && args.includes("--drain")) engineArgs.push("--drain")
   if (subcommand === "status" && args.includes("--include-workers")) engineArgs.push("--include-workers")
   return engineArgs
 }
 
-function parseLine(stdout) {
-  const line = stdout.trim().split("\n").filter(Boolean).pop()
-  if (line === undefined) return undefined
-  try {
-    return JSON.parse(line)
-  } catch {
-    return undefined
-  }
-}
-
 /** What a child process needs in its environment to reach this daemon rather than start its own. */
 function attachEnv(parsed, agentDir) {
   return {
@@ -123,7 +115,7 @@ function summarize(subcommand, parsed, exitCode) {
  * @returns the process exit code the launcher should use
  */
 export function runDaemonCommand(args, options) {
-  const { engine, pluginRoot, agentDir, env, stdout, stderr, platform } = options
+  const { engine, migration, pluginRoot, agentDir, env, stdout, stderr, platform } = options
   const subcommand = args[0]
 
   if (subcommand === "--help" || subcommand === "-h") {
@@ -141,9 +133,13 @@ export function runDaemonCommand(args, options) {
   // A named pipe is per-process on win32: there is no socket for a second client to attach to,
   // so refusing here is honest, where pretending would strand the caller on a host it cannot reach.
   if (platform === "win32") {
-    stderr.write("omo daemon: a shared host needs a unix socket, which win32 does not provide\n")
+    stderr.write("omo daemon: a task host needs a unix socket, which win32 does not provide\n")
     return DAEMON_EXIT.unsupported
   }
+  if (args.includes("--foreground")) {
+    stderr.write("omo daemon: --foreground is unsupported; the engine host always detaches\n")
+    return DAEMON_EXIT.usage
+  }
 
   // Only the subcommands that may START something need the spec; asking who is serving, or
   // asking it to stop, must still work on an install whose plugin payload was never built.
@@ -154,9 +150,82 @@ export function runDaemonCommand(args, options) {
   }
 
   const config = readConfig(agentDir)
-  const engineArgs = buildArgs(subcommand, args, { specPath, policy: resolvePolicy(args, config), config })
-  const result = engine.run(engineArgs, { env: { ...env, OMO_AGENT_DIR: agentDir } })
-  const parsed = parseLine(result.stdout ?? "")
+  if (subcommand === "status") {
+    const status = runStatus({
+      engine,
+      agentDir,
+      env,
+      json: args.includes("--json"),
+      stdout,
+      stderr,
+    })
+    if (!status.legacy) return status.exitCode
+  }
+  if (subcommand === "gc") {
+    if (args.includes("--prune-store-index") && migration === undefined) {
+      stderr.write("omo daemon: rollback migration runtime is unavailable\n")
+      return DAEMON_EXIT.engineRefused
+    }
+    return runGc({
+      engine,
+      migration,
+      agentDir,
+      env,
+      json: args.includes("--json"),
+      pruneStoreIndex: args.includes("--prune-store-index"),
+      stdout,
+      stderr,
+    })
+  }
+  if (subcommand === "rollback-prepare") {
+    if (migration === undefined) {
+      stderr.write("omo daemon: rollback migration runtime is unavailable\n")
+      return DAEMON_EXIT.engineRefused
+    }
+    return runRollbackPrepare({
+      engine,
+      migration,
+      agentDir,
+      env,
+      explicitStores: parseStoreArgs(args),
+      allowMissingIndex: args.includes("--allow-missing-index"),
+      dryRun: args.includes("--dry-run"),
+      json: args.includes("--json"),
+      stdout,
+      stderr,
+    })
+  }
+  if (subcommand === "handoff") {
+    return runHandoff({
+      engine,
+      pluginRoot,
+      agentDir,
+      env,
+      policy: resolvePolicy(args, config),
+      config,
+      stdout,
+      stderr,
+    })
+  }
+  if (subcommand === "stop" && args.includes("--all")) {
+    const timeoutSeconds = readTimeoutSeconds(args)
+    const outcome = runStopAll({
+      engine,
+      agentDir,
+      env,
+      drain: args.includes("--drain"),
+      wait: args.includes("--wait"),
+      timeoutSeconds,
+      stdout,
+      stderr,
+      now: options.now ?? Date.now,
+      pause: options.pause ?? blockingPause,
+    })
+    if (outcome !== undefined) return outcome
+  }
+  const engineArgs = buildArgs(subcommand, args, { specPath, policy: resolvePolicy(args, config) })
+  const result = engine.run(engineArgs, { env: hostCommandEnvironment(env, agentDir, config) })
+  const parsed = parseEngineLine(result.stdout ?? "")
 
   if (result.stderr) stderr.write(result.stderr)
 
@@ -165,7 +234,7 @@ export function runDaemonCommand(args, options) {
     const daemonEnv = attachEnv(parsed, agentDir)
     // `omo daemon attach --model x`: the trailing args are a normal omo launch that should run
     // against the daemon, so the caller gets the merged environment back and continues with them.
-    const launchArgs = args.slice(1).filter((arg) => !DAEMON_FLAGS.has(arg))
+    const launchArgs = attachLaunchArgs(args)
     if (launchArgs.length > 0) return { passthrough: true, args: launchArgs, env: { ...env, ...daemonEnv } }
     const payload = { ...(parsed ?? {}), env: daemonEnv }
     if (args.includes("--json")) stdout.write(`${JSON.stringify(payload)}\n`)
@@ -177,29 +246,3 @@ export function runDaemonCommand(args, options) {
   else stdout.write(`${summarize(subcommand, parsed, result.exitCode)}\n`)
   return result.exitCode
 }
-
-/**
- * The `omo doctor` view: one INFO line, never a FAIL - a machine without a daemon is healthy,
- * it just has nothing shared to report. Returned as lines so doctor can place it with the rest.
- */
-export function daemonReportLines({ engine, pluginRoot, agentDir, env, platform }) {
-  if (platform === "win32") return ["INFO Daemon: unavailable on win32 (no unix socket to share)"]
-  const stdout = { write() {} }
-  const captured = []
-  const exitCode = runDaemonCommand(["status", "--json"], {
-    engine, pluginRoot, agentDir, env, platform,
-    stdout: { write: (text) => void captured.push(text) },
-    stderr: stdout,
-  })
-  const parsed = parseLine(captured.join(""))
-  if (exitCode !== DAEMON_EXIT.ok || parsed === undefined) return ["INFO Daemon: not running"]
-  const sessions = parsed.sessions?.total ?? parsed.sessions?.length ?? 0
-  const parts = [
-    `pid ${parsed.pid}`,
-    parsed.instanceId === undefined ? undefined : `instance ${parsed.instanceId}`,
-    parsed.engineVersion === undefined ? undefined : `engine ${parsed.engineVersion}`,
-    `${sessions} session(s)`,
-    `zombies ${parsed.zombies ?? 0}`,
-  ].filter(Boolean)
-  return [`INFO Daemon: running ${parts.join(" · ")}`]
-}

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/launcher.js

@@ -210,6 +210,20 @@ export function engineHostCall(engineArgs, options) {
   return { exitCode: result.status ?? 1, stdout: result.stdout ?? "", stderr: result.stderr ?? "" }
 }
 
+export function rollbackMigrateCall(request) {
+  const runtime = join(packageRoot, "plugin", "runtime", "rollback-migrate.js")
+  const result = spawnSync(process.execPath, [runtime], {
+    encoding: "utf8",
+    input: JSON.stringify(request),
+    env: senpiEnvironment(preparedSenpi().packageRoot),
+    windowsHide: true,
+  })
+  if (result.status !== 0) {
+    throw new Error(result.stderr?.trim() || `rollback migration runtime exited ${result.status ?? 1}`)
+  }
+  return JSON.parse(result.stdout)
+}
+
 export async function runLauncher(args = process.argv.slice(2)) {
   migrateLegacyBunGlobalManifest()
   reportLegacyFlatAdoption()
@@ -226,6 +240,7 @@ export async function runLauncher(args = process.argv.slice(2)) {
   if (command === "daemon") {
     const outcome = runDaemonCommand(args.slice(1), {
       engine: { run: engineHostCall },
+      migration: { run: rollbackMigrateCall },
       pluginRoot: join(packageRoot, "plugin"),
       agentDir: canonicalAgentDir(),
       env: process.env,

package/bin/lib/provider-map.json

@@ -1,5 +1,5 @@
 {
-  "_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.",
+  "_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