omni-pi 0.3.0 → 0.4.0

package/README.md

@@ -14,27 +14,31 @@ Requires Node.js 22 or newer.
 
 - One friendly brain talks to the user.
 - `.omni/` remains the durable memory layer for goals, specs, tasks, checks, progress, and decisions.
-- Work is still broken into small, verifiable slices before code changes happen.
-- Verification remains explicit and should be recorded alongside implementation progress.
+- Work is broken into small, verifiable slices before code changes happen.
+- Verification is explicit and recorded alongside implementation progress.
 
 ## Install
 
-Install the package into Pi:
+Install the standalone executable:
 
 ```bash
-pi install npm:omni-pi
+npm install -g omni-pi
 ```
 
-For a project-local install instead of a global one:
+Then run it in any project:
 
 ```bash
-pi install -l npm:omni-pi
+cd your-project
+omni
 ```
 
 For local development from this checkout:
 
 ```bash
-pi install /Users/edgy/personal/Omni-Pi
+git clone https://github.com/EdGy2k/Omni-Pi.git
+cd Omni-Pi
+npm install
+npm run chat
 ```
 
 ## Use
@@ -66,14 +70,7 @@ Omni-Pi keeps its working notes in `.omni/`:
 
 ## Development
 
-```bash
-git clone https://github.com/EdGy2k/Omni-Pi.git
-cd Omni-Pi
-npm install
-npm run chat
-```
-
-`npm run chat` launches Pi with this package loaded from the local checkout.
+`npm run chat` launches the local `omni` wrapper from this checkout, which in turn starts Pi with this package loaded.
 
 For local verification:
 

package/bin/omni.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { realpathSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export function getOmniPackageDir() {
+  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+}
+
+export function resolvePiCliPath() {
+  return path.join(
+    getOmniPackageDir(),
+    "node_modules",
+    "@mariozechner",
+    "pi-coding-agent",
+    "dist",
+    "cli.js",
+  );
+}
+
+export function buildOmniEnvironment(baseEnv = process.env) {
+  return {
+    ...baseEnv,
+  };
+}
+
+export function buildPiProcessSpec(
+  argv = process.argv.slice(2),
+  baseEnv = process.env,
+) {
+  return {
+    command: process.execPath,
+    args: [resolvePiCliPath(), "-e", getOmniPackageDir(), ...argv],
+    env: buildOmniEnvironment(baseEnv),
+  };
+}
+
+export async function runOmni(argv = process.argv.slice(2), options = {}) {
+  const spec = buildPiProcessSpec(argv, options.env);
+
+  await new Promise((resolve, reject) => {
+    const child = spawn(spec.command, spec.args, {
+      cwd: options.cwd ?? process.cwd(),
+      env: spec.env,
+      stdio: "inherit",
+    });
+
+    const forwardSignal = (sig) => child.kill(sig);
+    process.on("SIGINT", forwardSignal);
+    process.on("SIGTERM", forwardSignal);
+
+    child.on("exit", (code, signal) => {
+      process.off("SIGINT", forwardSignal);
+      process.off("SIGTERM", forwardSignal);
+
+      if (signal) {
+        reject(new Error(`omni terminated with signal ${signal}`));
+        return;
+      }
+
+      process.exitCode = code ?? 0;
+      resolve(code ?? 0);
+    });
+    child.on("error", (err) => {
+      process.off("SIGINT", forwardSignal);
+      process.off("SIGTERM", forwardSignal);
+      reject(err);
+    });
+  });
+}
+
+export function isOmniEntrypointInvocation(
+  argvPath = process.argv[1],
+  moduleUrl = import.meta.url,
+) {
+  if (!argvPath) {
+    return false;
+  }
+
+  try {
+    return realpathSync(argvPath) === realpathSync(fileURLToPath(moduleUrl));
+  } catch {
+    return path.resolve(argvPath) === fileURLToPath(moduleUrl);
+  }
+}
+
+if (isOmniEntrypointInvocation()) {
+  runOmni().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}

package/extensions/omni-core/index.ts

@@ -4,13 +4,22 @@ import {
   buildBrainSystemPromptSuffix,
   ensureOmniInitialized,
 } from "../../src/brain.js";
+import { renderHeader } from "../../src/header.js";
+import { registerModelCommand } from "../../src/model-command.js";
 import { registerOmniMessageRenderer } from "../../src/pi.js";
+import { createOmniTheme } from "../../src/theme.js";
+import { registerThemeCommand } from "../../src/theme-command.js";
 
 export default function omniCoreExtension(api: ExtensionAPI): void {
   registerOmniMessageRenderer(api);
+  registerModelCommand(api);
+  registerThemeCommand(api);
 
   api.on("session_start", async (_event, ctx) => {
     await ensureOmniInitialized(ctx.cwd);
+    ctx.ui.setTitle("Omni-Pi");
+    ctx.ui.setTheme(createOmniTheme());
+    ctx.ui.setHeader((_tui, theme) => renderHeader(theme));
     ctx.ui.setStatus("omni", undefined);
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omni-pi",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Single-agent Pi package that interviews the user, documents the spec, and implements work in bounded slices.",
   "type": "module",
   "license": "MIT",
@@ -16,6 +16,9 @@
   "engines": {
     "node": ">=22"
   },
+  "bin": {
+    "omni": "bin/omni.js"
+  },
   "keywords": [
     "pi-package",
     "pi",
@@ -25,6 +28,7 @@
     "interview"
   ],
   "files": [
+    "bin",
     "agents",
     "extensions",
     "prompts",
@@ -35,7 +39,7 @@
     "CREDITS.md"
   ],
   "scripts": {
-    "chat": "node ./node_modules/@mariozechner/pi-coding-agent/dist/cli.js -e .",
+    "chat": "node ./bin/omni.js",
     "check": "tsc --noEmit",
     "lint": "biome check .",
     "format": "biome check --write .",
@@ -53,10 +57,12 @@
     "extensions": [
       "./extensions/omni-providers/index.ts",
       "./extensions/omni-core/index.ts",
-      "./extensions/omni-memory/index.ts"
+      "./extensions/omni-memory/index.ts",
+      "./node_modules/pi-web-access/index.ts"
     ],
     "skills": [
-      "./skills"
+      "./skills",
+      "./node_modules/pi-web-access/skills"
     ],
     "prompts": [
       "./prompts"
@@ -66,6 +72,7 @@
     "@anthropic-ai/claude-agent-sdk": "0.2.84",
     "@mariozechner/pi-coding-agent": "^0.62.0",
     "pi-subagents": "^0.11.11",
+    "pi-web-access": "^0.10.3",
     "zod": "^4.3.6"
   }
 }

package/src/brain.ts

@@ -2,6 +2,7 @@ import { access, readFile } from "node:fs/promises";
 import path from "node:path";
 
 import type { OmniState } from "./contracts.js";
+import { ensurePiSettings, loadSavedTheme } from "./theme.js";
 import { initializeOmniProject, readOmniStatus } from "./workflow.js";
 
 const BRAIN_SYSTEM_APPEND = `## Omni-Pi Single-Brain Mode
@@ -69,6 +70,8 @@ function clipSection(value: string | null, maxChars: number): string {
 export async function ensureOmniInitialized(
   cwd: string,
 ): Promise<"initialized" | "existing"> {
+  await ensurePiSettings(cwd);
+  loadSavedTheme(cwd);
   const statePath = path.join(cwd, ".omni", "STATE.md");
   if (await fileExists(statePath)) {
     return "existing";

package/src/header.ts

@@ -0,0 +1,76 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import type { Theme } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+
+import { brand, welcome as welcomeColor } from "./theme.js";
+
+const WELCOME_MESSAGES: readonly string[] = [
+  "Ready to turn ideas into code.",
+  "What are we building today?",
+  "Your brain is warmed up and ready.",
+  "Let's ship something great.",
+  "All systems nominal. Awaiting orders.",
+  "Standing by for your next move.",
+  "The plan-build-verify loop awaits.",
+  "Focus loaded. Distractions discarded.",
+  "Initialized. Let's make it happen.",
+  "Another day, another deploy.",
+  "Spec it. Build it. Verify it.",
+  "Engineering mode: activated.",
+  "Coffee optional. Code inevitable.",
+  "Ctrl+C is always an option. But not today.",
+];
+
+export const ASCII_LOGO = [
+  " ██████╗ ███╗   ███╗███╗   ██╗██╗",
+  "██╔═══██╗████╗ ████║████╗  ██║██║",
+  "██║   ██║██╔████╔██║██╔██╗ ██║██║",
+  "██║   ██║██║╚██╔╝██║██║╚██╗██║██║",
+  "╚██████╔╝██║ ╚═╝ ██║██║ ╚████║██║",
+  " ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═══╝╚═╝",
+];
+
+export const LOGO_WIDTH = Math.max(...ASCII_LOGO.map((l) => l.length));
+
+export function centerIn(text: string, width: number): string {
+  const pad = Math.max(0, Math.floor((width - text.length) / 2));
+  return " ".repeat(pad) + text;
+}
+
+function readVersion(): string {
+  try {
+    const pkgPath = path.resolve(
+      path.dirname(fileURLToPath(import.meta.url)),
+      "..",
+      "package.json",
+    );
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as {
+      version?: string;
+    };
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+export function pickWelcome(): string {
+  return WELCOME_MESSAGES[Math.floor(Math.random() * WELCOME_MESSAGES.length)];
+}
+
+export function renderHeader(theme: Theme): Text {
+  const version = readVersion();
+  const welcome = pickWelcome();
+
+  const logo = ASCII_LOGO.map((line) => brand(line)).join("\n");
+  const subtitleText = `— P I  v${version} —`;
+  const subtitle = theme.fg("muted", centerIn(subtitleText, LOGO_WIDTH));
+  const taglineText = "plan · build · verify";
+  const tagline = theme.fg("muted", centerIn(taglineText, LOGO_WIDTH));
+  const greeting = welcomeColor(centerIn(welcome, LOGO_WIDTH));
+
+  const lines = [logo, subtitle, "", tagline, greeting, ""];
+  return new Text(lines.join("\n"), 1, 0);
+}

package/src/model-command.ts

@@ -0,0 +1,47 @@
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+} from "@mariozechner/pi-coding-agent";
+
+import {
+  getAuthenticatedModelOptions,
+  setupCustomProviderModel,
+} from "./model-setup.js";
+
+async function handleAdd(ctx: ExtensionCommandContext): Promise<void> {
+  const result = await setupCustomProviderModel({ ctx });
+  ctx.ui.notify(result.summary, "info");
+}
+
+async function handleList(ctx: ExtensionCommandContext): Promise<void> {
+  const models = getAuthenticatedModelOptions(ctx.modelRegistry);
+
+  if (models.length === 0) {
+    ctx.ui.notify("No models available.", "info");
+    return;
+  }
+
+  await ctx.ui.select("Available models:", models);
+}
+
+export function registerModelCommand(api: ExtensionAPI): void {
+  api.registerCommand("model-setup", {
+    description: "Add or list custom model providers",
+    async handler(args: string, ctx: ExtensionCommandContext) {
+      const sub = args.trim().toLowerCase();
+
+      if (sub === "add") return handleAdd(ctx);
+      if (sub === "list") return handleList(ctx);
+
+      const choice = await ctx.ui.select("Model setup:", [
+        "add    — Add a custom provider/model",
+        "list   — Show available models",
+      ]);
+      if (!choice) return;
+
+      const picked = choice.split("—")[0].trim();
+      if (picked === "add") return handleAdd(ctx);
+      if (picked === "list") return handleList(ctx);
+    },
+  });
+}

package/src/theme-command.ts

@@ -0,0 +1,141 @@
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+} from "@mariozechner/pi-coding-agent";
+import type { Component, KeybindingsManager, TUI } from "@mariozechner/pi-tui";
+import {
+  ASCII_LOGO,
+  centerIn,
+  LOGO_WIDTH,
+  pickWelcome,
+  renderHeader,
+} from "./header.js";
+import {
+  ansiColor,
+  applyPreset,
+  createOmniTheme,
+  getActivePresetName,
+  PRESETS,
+  saveThemeChoice,
+} from "./theme.js";
+
+const PRESET_KEYS = Object.keys(PRESETS);
+
+function renderMiniPreview(brandHex: string, welcomeHex: string): string[] {
+  const logo = ASCII_LOGO.map((line) => ansiColor(brandHex, line));
+  const tagline = ansiColor(
+    "#808080",
+    centerIn("plan · build · verify", LOGO_WIDTH),
+  );
+  const greeting = ansiColor(welcomeHex, centerIn(pickWelcome(), LOGO_WIDTH));
+  return [...logo, "", tagline, greeting];
+}
+
+type PickerResult = { key: string } | "cancelled";
+
+class ThemePickerComponent implements Component {
+  private selectedIndex: number;
+  private tui: TUI;
+  private kb: KeybindingsManager;
+  private done: (result: PickerResult) => void;
+  private originalKey: string;
+
+  invalidate(): void {
+    // No cached state to clear — render() is always fresh.
+  }
+
+  constructor(
+    tui: TUI,
+    keybindings: KeybindingsManager,
+    done: (result: PickerResult) => void,
+    currentKey: string,
+  ) {
+    this.tui = tui;
+    this.kb = keybindings;
+    this.done = done;
+    this.originalKey = currentKey;
+    this.selectedIndex = Math.max(0, PRESET_KEYS.indexOf(currentKey));
+  }
+
+  handleInput(data: string): void {
+    const prev = this.selectedIndex;
+
+    if (this.kb.matches(data, "tui.select.up")) {
+      this.selectedIndex =
+        this.selectedIndex === 0
+          ? PRESET_KEYS.length - 1
+          : this.selectedIndex - 1;
+    } else if (this.kb.matches(data, "tui.select.down")) {
+      this.selectedIndex =
+        this.selectedIndex === PRESET_KEYS.length - 1
+          ? 0
+          : this.selectedIndex + 1;
+    } else if (this.kb.matches(data, "tui.select.confirm")) {
+      this.done({ key: PRESET_KEYS[this.selectedIndex] });
+      return;
+    } else if (this.kb.matches(data, "tui.select.cancel")) {
+      this.done("cancelled");
+      return;
+    }
+
+    if (prev !== this.selectedIndex) {
+      this.tui.requestRender(true);
+    }
+  }
+
+  render(width: number): string[] {
+    const key = PRESET_KEYS[this.selectedIndex];
+    const preset = PRESETS[key];
+
+    // ── Preview ──
+    const preview = renderMiniPreview(preset.brand, preset.welcome);
+
+    // ── List ──
+    const listLines = PRESET_KEYS.map((k, i) => {
+      const p = PRESETS[k];
+      const swatch = ansiColor(p.brand, "████");
+      const welcomeSwatch = ansiColor(p.welcome, "██");
+      const current = k === this.originalKey ? " *" : "";
+      const label = `${swatch} ${welcomeSwatch}  ${p.label}${current}`;
+      return i === this.selectedIndex ? ` > ${label}` : `   ${label}`;
+    });
+
+    const separator = "─".repeat(Math.min(width, LOGO_WIDTH + 4));
+    const hint = "\x1b[2m↑/↓ navigate · enter select · esc cancel\x1b[0m";
+
+    return ["", ...preview, "", separator, ...listLines, "", hint, ""];
+  }
+}
+
+export function registerThemeCommand(api: ExtensionAPI): void {
+  api.registerCommand("theme", {
+    description: "Pick an Omni-Pi color theme with live preview",
+    async handler(_args: string, ctx: ExtensionCommandContext) {
+      const originalKey = getActivePresetName() ?? "lavender";
+
+      const result = await ctx.ui.custom<PickerResult>(
+        (tui, _theme, keybindings, done) =>
+          new ThemePickerComponent(tui, keybindings, done, originalKey),
+      );
+
+      if (result === "cancelled") {
+        // Revert to original
+        applyPreset(originalKey);
+        ctx.ui.setTheme(createOmniTheme());
+        ctx.ui.setHeader((_tui, theme) => renderHeader(theme));
+        return;
+      }
+
+      applyPreset(result.key);
+      ctx.ui.setTheme(createOmniTheme());
+      ctx.ui.setHeader((_tui, theme) => renderHeader(theme));
+      saveThemeChoice(ctx.cwd, result.key);
+
+      const chosen = PRESETS[result.key];
+      ctx.ui.notify(
+        `Theme set to ${ansiColor(chosen.brand, chosen.label)}`,
+        "info",
+      );
+    },
+  });
+}

package/src/theme.ts

@@ -0,0 +1,242 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+
+import { Theme } from "@mariozechner/pi-coding-agent";
+
+// ── Curated presets ──────────────────────────────────────────────
+
+export interface OmniPreset {
+  readonly label: string;
+  readonly brand: string;
+  readonly welcome: string;
+}
+
+export const PRESETS: Record<string, OmniPreset> = {
+  lavender: {
+    label: "Lavender",
+    brand: "#c5bceb",
+    welcome: "#4969c9",
+  },
+  ember: {
+    label: "Ember",
+    brand: "#e8836b",
+    welcome: "#d4a054",
+  },
+  ocean: {
+    label: "Ocean",
+    brand: "#5fb3d4",
+    welcome: "#4a90b8",
+  },
+  mint: {
+    label: "Mint",
+    brand: "#7ecba1",
+    welcome: "#52a37a",
+  },
+  rose: {
+    label: "Rose",
+    brand: "#e88aaf",
+    welcome: "#c76b8f",
+  },
+  gold: {
+    label: "Gold",
+    brand: "#d4b96a",
+    welcome: "#b89b4a",
+  },
+  arctic: {
+    label: "Arctic",
+    brand: "#a0c4e8",
+    welcome: "#7ba3cc",
+  },
+  neon: {
+    label: "Neon",
+    brand: "#b97aff",
+    welcome: "#ff6bde",
+  },
+  copper: {
+    label: "Copper",
+    brand: "#d4956a",
+    welcome: "#b87a4f",
+  },
+  slate: {
+    label: "Slate",
+    brand: "#8fa3b8",
+    welcome: "#6b8299",
+  },
+};
+
+export const DEFAULT_PRESET = "lavender";
+
+// ── Runtime state ────────────────────────────────────────────────
+
+let activeBrand = PRESETS[DEFAULT_PRESET].brand;
+let activeWelcome = PRESETS[DEFAULT_PRESET].welcome;
+let activePresetName: string | null = DEFAULT_PRESET;
+
+export function getBrandHex(): string {
+  return activeBrand;
+}
+
+export function getWelcomeHex(): string {
+  return activeWelcome;
+}
+
+export function getActivePresetName(): string | null {
+  return activePresetName;
+}
+
+export function applyPreset(name: string): void {
+  const preset = PRESETS[name];
+  if (!preset) return;
+  activeBrand = preset.brand;
+  activeWelcome = preset.welcome;
+  activePresetName = name;
+}
+
+// ── Persistence (.pi/settings.json) ─────────────────────────────
+
+interface PiSettings {
+  quietStartup?: boolean;
+  omniTheme?: string;
+  [key: string]: unknown;
+}
+
+function settingsPath(cwd: string): string {
+  return path.join(cwd, ".pi", "settings.json");
+}
+
+function readSettings(cwd: string): PiSettings {
+  try {
+    return JSON.parse(readFileSync(settingsPath(cwd), "utf8")) as PiSettings;
+  } catch {
+    return {};
+  }
+}
+
+function writeSettings(cwd: string, settings: PiSettings): void {
+  writeFileSync(
+    settingsPath(cwd),
+    `${JSON.stringify(settings, null, 2)}\n`,
+    "utf8",
+  );
+}
+
+export async function ensurePiSettings(cwd: string): Promise<void> {
+  const p = settingsPath(cwd);
+  try {
+    readFileSync(p);
+  } catch {
+    await mkdir(path.join(cwd, ".pi"), { recursive: true });
+    writeSettings(cwd, { quietStartup: true });
+  }
+}
+
+/** Load the saved theme from .pi/settings.json, or fall back to default. */
+export function loadSavedTheme(cwd: string): void {
+  const settings = readSettings(cwd);
+  const name = settings.omniTheme;
+  if (typeof name === "string" && name in PRESETS) {
+    applyPreset(name);
+  } else {
+    applyPreset(DEFAULT_PRESET);
+  }
+}
+
+/** Persist the chosen preset to .pi/settings.json. */
+export function saveThemeChoice(cwd: string, presetName: string): void {
+  const settings = readSettings(cwd);
+  writeSettings(cwd, { ...settings, omniTheme: presetName });
+}
+
+// ── ANSI helpers ─────────────────────────────────────────────────
+
+const ANSI_RESET = "\x1b[0m";
+
+function hexToRgb(hex: string): { r: number; g: number; b: number } {
+  const n = Number.parseInt(hex.replace("#", ""), 16);
+  return { r: (n >> 16) & 0xff, g: (n >> 8) & 0xff, b: n & 0xff };
+}
+
+export function ansiColor(hex: string, text: string): string {
+  const { r, g, b } = hexToRgb(hex);
+  return `\x1b[38;2;${r};${g};${b}m${text}${ANSI_RESET}`;
+}
+
+/** Wrap text in true-color ANSI foreground using the active brand color. */
+export function brand(text: string): string {
+  return ansiColor(activeBrand, text);
+}
+
+/** Wrap text in true-color ANSI foreground using the active welcome color. */
+export function welcome(text: string): string {
+  return ansiColor(activeWelcome, text);
+}
+
+// ── Theme constructor ────────────────────────────────────────────
+
+/**
+ * Omni-Pi theme — dark base with brand accent.
+ * Reads the active brand color so `/theme` changes propagate.
+ */
+export function createOmniTheme(): Theme {
+  const accent = activeBrand;
+  return new Theme(
+    {
+      accent,
+      border: "#5f87ff",
+      borderAccent: accent,
+      borderMuted: "#505050",
+      success: "#b5bd68",
+      error: "#cc6666",
+      warning: "#ffff00",
+      muted: "#808080",
+      dim: "#666666",
+      text: "",
+      thinkingText: "#808080",
+      userMessageText: "",
+      customMessageText: "",
+      customMessageLabel: "#9575cd",
+      toolTitle: "",
+      toolOutput: "#808080",
+      mdHeading: "#f0c674",
+      mdLink: "#81a2be",
+      mdLinkUrl: "#666666",
+      mdCode: accent,
+      mdCodeBlock: "#b5bd68",
+      mdCodeBlockBorder: "#808080",
+      mdQuote: "#808080",
+      mdQuoteBorder: "#808080",
+      mdHr: "#808080",
+      mdListBullet: accent,
+      toolDiffAdded: "#b5bd68",
+      toolDiffRemoved: "#cc6666",
+      toolDiffContext: "#808080",
+      syntaxComment: "#6A9955",
+      syntaxKeyword: "#569CD6",
+      syntaxFunction: "#DCDCAA",
+      syntaxVariable: "#9CDCFE",
+      syntaxString: "#CE9178",
+      syntaxNumber: "#B5CEA8",
+      syntaxType: "#4EC9B0",
+      syntaxOperator: "#D4D4D4",
+      syntaxPunctuation: "#D4D4D4",
+      thinkingOff: "#505050",
+      thinkingMinimal: "#6e6e6e",
+      thinkingLow: "#5f87af",
+      thinkingMedium: "#81a2be",
+      thinkingHigh: "#b294bb",
+      thinkingXhigh: "#d183e8",
+      bashMode: "#b5bd68",
+    },
+    {
+      selectedBg: "#3a3a4a",
+      userMessageBg: "#343541",
+      customMessageBg: "#2d2838",
+      toolPendingBg: "#282832",
+      toolSuccessBg: "#283228",
+      toolErrorBg: "#3c2828",
+    },
+    "truecolor",
+    { name: "omni" },
+  );
+}