okengine 0.10.3 → 0.11.0

package/src/cli/drizzle-env.ts

@@ -64,36 +64,43 @@ export async function applyComposeEnvToProcess(cwd: string): Promise<readonly st
  * Dialect comes from the configured driver via the exhaustive
  * `SQL_DRIVER_TO_DRIZZLE_DIALECT` map — a missing/unsupported driver id is a
  * compile-time gap there, and a clear runtime error here (never a silent
- * sqlite fallback).
+ * fallback).
  *
  * @param cwd - Project root
- * @param config - Loaded `oke.config.ts` (null → sqlite/local defaults)
- * @param env - Active env (`local` | `docker` for dev tooling)
+ * @param config - Loaded `oke.config.ts` (null → postgres/dev defaults)
+ * @param env - Active {@link ConfigEnv}
  */
 export async function resolveDrizzleKitEnv(
   cwd: string,
   config: OkeConfig | null | undefined,
   env: ConfigEnv,
 ): Promise<DrizzleKitEnvContext> {
-  const driverId = resolveDriverId(config?.drivers?.store?.sql, env) ?? "sqlite";
-  if (driverId !== "sqlite" && driverId !== "postgres") {
+  const driverId = resolveDriverId(config?.drivers?.store?.sql, env) ?? "postgres";
+  if (driverId !== "postgres" && driverId !== "pglite") {
     throw new Error(
-      `oke db: store.sql driver "${driverId}" is not supported by drizzle-kit (sqlite | postgres)`,
+      `oke db: store.sql driver "${driverId}" is not supported by drizzle-kit (postgres | pglite)`,
     );
   }
   const dialect = drizzleDialectFromSqlDriver(driverId);
 
-  const compose = env === "docker" ? await readComposeEnv(cwd) : new Map<string, string>();
+  const compose = env === "dev" ? await readComposeEnv(cwd) : new Map<string, string>();
 
   const overlay: Record<string, string> = { OKE_DRIZZLE_DIALECT: dialect };
-  if (dialect === "postgresql") {
+  if (driverId === "pglite") {
     const url =
+      process.env.OKE_PGLITE_URL ??
+      compose.get("OKE_PGLITE_URL") ??
+      (env === "test" ? "memory://" : ".oke/pgdata");
+    overlay.OKE_PGLITE_URL = url;
+    // drizzle-kit still wants a postgres-shaped URL for dialect postgresql when
+    // not using PGlite kit plugins — prefer DATABASE_URL from compose for push.
+    const pgUrl =
       process.env.DATABASE_URL ?? compose.get("DATABASE_URL") ?? compose.get("OKE_STORE_SQL_URL");
-    if (url !== undefined) overlay.DATABASE_URL = url;
+    if (pgUrl !== undefined) overlay.DATABASE_URL = pgUrl;
   } else {
     const url =
-      process.env.OKE_SQLITE_URL ?? compose.get("OKE_SQLITE_URL") ?? "file:.oke/app.sqlite";
-    overlay.OKE_SQLITE_URL = url;
+      process.env.DATABASE_URL ?? compose.get("DATABASE_URL") ?? compose.get("OKE_STORE_SQL_URL");
+    if (url !== undefined) overlay.DATABASE_URL = url;
   }
   return { env, dialect, overlay };
 }

package/src/cli/ensure-drizzle-config.ts

@@ -5,32 +5,29 @@
 
 import { resolve } from "node:path";
 
-/** Mode-aware template (matches create-oke templates' drizzle.config.ts). */
+/** PostgreSQL-only template (matches create-oke templates' drizzle.config.ts). */
 const DRIZZLE_CONFIG_TEMPLATE = `import { defineConfig } from "drizzle-kit";
 
 /**
  * Domain schema sync for \`oke db push|generate|migrate\`.
  *
- * Dialect comes from OKE's \`store.sql\` driver map (resolved by the CLI and
- * injected as \`OKE_DRIZZLE_DIALECT\`) — never inferred from \`DATABASE_URL\`
- * presence. \`src/db/schema.generated.ts\` is emitted from \`src/db/schema.decl.ts\`
- * for the active dialect as a pre-step of \`oke db\` / \`oke dev\`.
+ * SQL is PostgreSQL-only (postgres / pglite). Domain tables come from
+ * \`src/db/schema.decl.ts\` → \`src/db/schema.drizzle.ts\` (emitted as a
+ * pre-step of \`oke db\` / \`oke dev\`).
  *
- * Versioned prod migrations land in \`./src/db/migrations\` — never mix with \`.oke/\`.
+ * System / auth / plugin stubs are separate: \`oke schema generate\` →
+ * \`.oke/schema/oke.ts\` (gitignored with \`.oke/\`). Re-run after adding plugins.
+ *
+ * Versioned prod migrations land in \`./src/db/migrations\`.
  */
-const dialect = (process.env.OKE_DRIZZLE_DIALECT ?? "sqlite") as "sqlite" | "postgresql";
-
 export default defineConfig({
-  dialect,
-  schema: "./src/db/schema.generated.ts",
+  dialect: "postgresql",
+  schema: "./src/db/schema.drizzle.ts",
   out: "./src/db/migrations",
   // Core runtime tables (oke_crons, …) are created by drivers — not domain schema.
   tablesFilter: ["!oke_*"],
   dbCredentials: {
-    url:
-      dialect === "postgresql"
-        ? (process.env.DATABASE_URL ?? process.env.OKE_STORE_SQL_URL!)
-        : (process.env.OKE_SQLITE_URL ?? "file:.oke/app.sqlite"),
+    url: process.env.DATABASE_URL ?? process.env.OKE_STORE_SQL_URL!,
   },
 });
 `;

package/src/cli/hero-meta.test.ts

@@ -15,23 +15,23 @@ import {
 const SAMPLE: OkeConfig = {
   drivers: {
     store: {
-      sql: { local: "sqlite", docker: "postgres", prod: "postgres" },
-      kv: { local: "memory", docker: "redis", prod: "redis" },
+      sql: { dev: "postgres", test: "pglite", prod: "postgres" },
+      kv: { dev: "redis", test: "memory", prod: "redis" },
     },
-    signal: { local: "memory", docker: "redis", prod: "redis" },
-    clock: { local: "memory", docker: "file", prod: "file" },
-    vault: { local: "env", docker: "openbao", prod: "openbao" },
+    signal: { dev: "redis", test: "memory", prod: "redis" },
+    clock: { dev: "file", test: "memory", prod: "file" },
+    vault: { dev: "vault", test: "env", prod: "vault" },
     channel: {
-      email: { local: "console", docker: "smtp", prod: "smtp" },
+      email: { dev: "smtp", test: "console", prod: "smtp" },
     },
-    ai: { local: "mock", docker: "mock" },
+    ai: { dev: "mock", test: "mock" },
   },
 };
 
 describe("hero-meta", () => {
-  test("resolveDevProfile maps docker and NODE_ENV", () => {
-    expect(resolveDevProfile({ docker: false })).toBe("local");
-    expect(resolveDevProfile({ docker: true })).toBe("docker");
+  test("resolveDevProfile maps NODE_ENV (docker flag ignored)", () => {
+    expect(resolveDevProfile({ docker: false })).toBe("dev");
+    expect(resolveDevProfile({ docker: true })).toBe("dev");
     expect(resolveDevProfile({ docker: false, nodeEnv: "test" })).toBe("test");
     expect(resolveDevProfile({ docker: false, nodeEnv: "production" })).toBe("production");
   });
@@ -48,12 +48,12 @@ describe("hero-meta", () => {
       "channel",
       "ai",
     ]);
-    expect(rows.find((r) => r.element === "store")?.detail).toContain("sqlite");
+    expect(rows.find((r) => r.element === "store")?.detail).toContain("pglite");
     expect(rows.find((r) => r.element === "flow")?.detail).toBe("");
     expect(rows.find((r) => r.element === "flow")?.status).toBe("ready");
   });
 
-  test("docker profile applies to every element", () => {
+  test("dev (compose) profile applies to every element", () => {
     const rows = resolveHeroElements(SAMPLE, {
       docker: true,
       sqlDriver: "postgres",
@@ -62,7 +62,7 @@ describe("hero-meta", () => {
     const store = rows.find((r) => r.element === "store")?.detail ?? "";
     expect(store).toContain("postgres");
     expect(store).toContain("redis");
-    expect(store).not.toContain("sqlite");
+    expect(store).not.toContain("pglite");
     expect(rows.find((r) => r.element === "signal")?.detail).toBe("redis");
     expect(rows.find((r) => r.element === "clock")?.detail).toBe("file");
     expect(rows.find((r) => r.element === "gate")?.detail).toBe("redis");
@@ -78,8 +78,8 @@ describe("hero-meta", () => {
       version: "0.2.4",
       nodeEnv: "development",
     });
-    expect(snap.profile).toBe("docker");
-    expect(snap.runtimeEnv).toBe("local");
+    expect(snap.profile).toBe("dev");
+    expect(snap.runtimeEnv).toBe("dev");
     expect(decodeHeroSnapshot(encodeHeroSnapshot(snap))).toEqual(snap);
   });
 

package/src/cli/hero-meta.ts

@@ -11,11 +11,11 @@ import {
 } from "../config/index.ts";
 import type { DevStatus } from "../term.ts";
 
-/** How the process is running (local laptop → production). */
-export type DevRuntimeProfile = "local" | "docker" | "test" | "production";
+/** How the process is running (dev Compose → production). */
+export type DevRuntimeProfile = "dev" | "test" | "production";
 
-/** Data plane: still on a laptop vs real production. */
-export type DevRuntimeEnv = "local" | "production";
+/** Data plane: still on a laptop vs production deploy. */
+export type DevRuntimeEnv = "dev" | "production";
 
 /** One of the eight elements with its active driver summary. */
 export type HeroElementRow = {
@@ -69,16 +69,17 @@ export function resolveDevProfile(options: {
 }): DevRuntimeProfile {
   if (options.nodeEnv === "test") return "test";
   if (options.nodeEnv === "production") return "production";
-  return options.docker ? "docker" : "local";
+  void options.docker;
+  return "dev";
 }
 
 /**
- * Data-plane environment (local machine vs production deploy).
+ * Data-plane environment (dev machine vs production deploy).
  *
  * @param profile - Runtime profile
  */
 export function resolveDevRuntimeEnv(profile: DevRuntimeProfile): DevRuntimeEnv {
-  return profile === "production" ? "production" : "local";
+  return profile === "production" ? "production" : "dev";
 }
 
 /**
@@ -155,13 +156,13 @@ export function resolveHeroElements(
     readonly aiModel?: string;
     /** AI readiness when known (model loading / ready). */
     readonly aiStatus?: DevStatus;
-    /** Which driver map column to read (default `local`). */
+    /** Which driver map column to read (default `test` unless `docker`). */
     readonly configEnv?: ConfigEnv;
   },
 ): readonly HeroElementRow[] {
   const drivers = config?.drivers;
   // `-d` reads the `docker` profile for every element (not a store-only override).
-  const configEnv: ConfigEnv = options.configEnv ?? (options.docker ? "docker" : "local");
+  const configEnv: ConfigEnv = options.configEnv ?? (options.docker ? "dev" : "test");
 
   // Gate rates share `drivers.store.kv` (no separate drivers.gate).
   const gateKv =

package/src/cli/index.ts

@@ -1,6 +1,8 @@
 #!/usr/bin/env bun
 /**
  * `oke` CLI entry.
+ *
+ * Bare `oke` (TTY) → interactive Ink TUI. `oke <command>` runs directly.
  */
 
 import { aiCli } from "./ai.ts";
@@ -23,11 +25,32 @@ import { replayCli } from "./replay.ts";
 import { schemaCli } from "./schema.ts";
 import { stackCli } from "./stack.ts";
 import { startCli } from "./start.ts";
+import { testCli } from "./test.ts";
 import { upgradeCli } from "./upgrade.ts";
 import { vaultCli } from "./vault-cmd.ts";
 
-const argv = process.argv.slice(2);
+const rawArgv = process.argv.slice(2);
+const wantTui = rawArgv.includes("--tui");
+const argv = rawArgv.filter((a) => a !== "--tui");
 const [cmd, sub, ...rest] = argv;
+/** Nested TUI / slash child — never re-enter the interactive shell. */
+const noTui = process.env["OKE_NO_TUI"] === "1";
+
+/**
+ * Launch interactive TUI when allowed; otherwise print help (non-TTY).
+ */
+async function maybeLaunchTui(): Promise<never> {
+  const { canRenderTui, launchTui } = await import("./tui/launch.ts");
+  if (noTui || !canRenderTui(process.stdout)) {
+    console.log(formatOkeHelp());
+    process.exit(EXIT_USAGE);
+  }
+  process.exit(await launchTui(process.cwd()));
+}
+
+if (wantTui && !noTui) {
+  await maybeLaunchTui();
+}
 
 if (cmd === "dev") {
   process.exit(await devCli(sub ? [sub, ...rest] : rest));
@@ -37,6 +60,10 @@ if (cmd === "mode") {
   process.exit(await modeCli(sub ? [sub, ...rest] : rest));
 }
 
+if (cmd === "test") {
+  process.exit(await testCli(sub ? [sub, ...rest] : rest));
+}
+
 if (cmd === "start") {
   process.exit(await startCli(sub ? [sub, ...rest] : rest));
 }
@@ -109,11 +136,14 @@ if (cmd === "completion") {
   process.exit(completionCli(sub ? [sub, ...rest] : rest));
 }
 
-if (cmd === undefined || cmd === "--help" || cmd === "-h" || cmd === "help") {
-  // Bare `oke` — commands only. Exit-code table only on explicit --help.
-  const help = cmd === undefined ? formatOkeHelp() : `${formatOkeHelp()}${EXIT_CODE_HELP}`;
-  console.log(help);
-  process.exit(cmd ? EXIT_OK : EXIT_USAGE);
+if (cmd === "--help" || cmd === "-h" || cmd === "help") {
+  console.log(`${formatOkeHelp()}${EXIT_CODE_HELP}`);
+  process.exit(EXIT_OK);
+}
+
+if (cmd === undefined) {
+  // Bare `oke` — TUI on TTY; help + EXIT_USAGE when piped / CI / OKE_NO_TUI.
+  await maybeLaunchTui();
 }
 
 console.error(`Unknown command: ${cmd}${sub ? ` ${sub}` : ""}`);

package/src/cli/load-config.images.test.ts

@@ -14,9 +14,13 @@ describe("flattenImagesConfig", () => {
   test("flattens store/channel nesting to dotted keys; flat roles pass through", () => {
     expect(
       flattenImagesConfig({
-        store: { sql: "postgres:18-alpine", kv: "redis:8-alpine", files: "rustfs/rustfs:1.0.0" },
+        store: {
+          sql: "postgres:18-alpine",
+          kv: "redis:8-alpine",
+          files: "rustfs/rustfs:1.0.0",
+          index: "getmeili/meilisearch:v1.37",
+        },
         channel: { email: "axllent/mailpit:v1.22.3" },
-        vault: "openbao/openbao:2.6.1",
         ai: "ollama/ollama:0.32.6",
         pgdog: "ghcr.io/pgdogdev/pgdog:v0.1.51",
         proxy: "caddy:2-alpine",
@@ -25,8 +29,8 @@ describe("flattenImagesConfig", () => {
       "store.sql": "postgres:18-alpine",
       "store.kv": "redis:8-alpine",
       "store.files": "rustfs/rustfs:1.0.0",
+      "store.index": "getmeili/meilisearch:v1.37",
       "channel.email": "axllent/mailpit:v1.22.3",
-      vault: "openbao/openbao:2.6.1",
       ai: "ollama/ollama:0.32.6",
       pgdog: "ghcr.io/pgdogdev/pgdog:v0.1.51",
       proxy: "caddy:2-alpine",
@@ -97,7 +101,7 @@ describe("defaultImagesFromConfig", () => {
     expect(defaultImagesFromConfig({})).toEqual({});
     expect(
       defaultImagesFromConfig({
-        drivers: { store: { sql: { prod: "sqlite" } } },
+        drivers: { store: { sql: { prod: "memory" } } },
       }),
     ).toEqual({});
   });
@@ -132,20 +136,20 @@ describe("resolveImages", () => {
 });
 
 describe("dockerDevDriverMismatches", () => {
-  test("flags docker/prod sqlite/memory when containers are up", () => {
+  test("flags dev pglite/memory when containers are up", () => {
     const mismatches = dockerDevDriverMismatches(
       {
         drivers: {
           store: {
-            sql: { local: "sqlite", docker: "sqlite", prod: "sqlite" },
-            kv: { local: "memory", docker: "memory", prod: "memory" },
+            sql: { dev: "pglite", test: "pglite", prod: "postgres" },
+            kv: { test: "memory", dev: "memory", prod: "memory" },
           },
         },
       },
       ["store.sql", "store.kv"],
     );
     expect(mismatches).toEqual([
-      { label: "sql", using: "sqlite", container: "postgres" },
+      { label: "sql", using: "pglite", container: "postgres" },
       { label: "kv", using: "memory", container: "redis" },
     ]);
   });
@@ -155,8 +159,8 @@ describe("dockerDevDriverMismatches", () => {
       {
         drivers: {
           store: {
-            sql: { local: "sqlite", docker: "postgres", prod: "postgres" },
-            kv: { local: "memory", docker: "redis", prod: "redis" },
+            sql: { dev: "postgres", test: "pglite", prod: "postgres" },
+            kv: { dev: "redis", test: "memory", prod: "redis" },
           },
         },
       },
@@ -170,8 +174,8 @@ describe("dockerDevDriverMismatches", () => {
       {
         drivers: {
           store: {
-            sql: { local: "sqlite", prod: "postgres" },
-            kv: { local: "memory", prod: "redis" },
+            sql: { dev: "postgres", test: "pglite", prod: "postgres" },
+            kv: { dev: "redis", test: "memory", prod: "redis" },
           },
         },
       },

package/src/cli/load-config.source.test.ts

@@ -0,0 +1,50 @@
+/**
+ * CLI rejects removed env keys / drivers in oke.config source.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { assertOkeConfigSource, loadOkeConfig } from "./load-config.ts";
+
+describe("assertOkeConfigSource", () => {
+  test("rejects local: env keys", () => {
+    expect(() =>
+      assertOkeConfigSource(`drivers: { store: { sql: { local: "postgres" } } }`),
+    ).toThrow(`"local" is no longer a valid environment key in oke.config.ts.`);
+  });
+
+  test('rejects "sqlite" driver pins', () => {
+    expect(() => assertOkeConfigSource(`drivers: { store: { sql: { dev: "sqlite" } } }`)).toThrow(
+      `"sqlite" is no longer a valid driver in oke.config.ts.`,
+    );
+  });
+
+  test("allows modern three-key maps", () => {
+    expect(() =>
+      assertOkeConfigSource(`sql: { dev: "postgres", test: "pglite", prod: "postgres" }`),
+    ).not.toThrow();
+  });
+
+  test("does not false-positive on localhost", () => {
+    expect(() => assertOkeConfigSource(`url: "http://localhost:5432"`)).not.toThrow();
+  });
+});
+
+describe("loadOkeConfig source gate", () => {
+  test("fails before import when local: is present", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-cfg-local-"));
+    try {
+      await writeFile(
+        join(dir, "oke.config.ts"),
+        `export default { drivers: { store: { sql: { local: "postgres", test: "pglite", prod: "postgres" } } } };\n`,
+      );
+      await expect(loadOkeConfig(dir)).rejects.toThrow(
+        `"local" is no longer a valid environment key in oke.config.ts.`,
+      );
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/cli/load-config.ts

@@ -3,7 +3,13 @@
  */
 
 import { resolve } from "node:path";
-import { flattenImagesConfig, type DriverRef, type OkeConfig } from "../config/index.ts";
+import {
+  driverRefId,
+  flattenImagesConfig,
+  normalizeEnvDriverMap,
+  type EnvDriverInput,
+  type OkeConfig,
+} from "../config/index.ts";
 import type { Manifest } from "../manifest/types.ts";
 
 /** Default image pins when `images` is omitted but prod drivers need containers. */
@@ -11,27 +17,15 @@ const DEFAULT_SQL_IMAGE = "postgres:18-alpine";
 const DEFAULT_PGVECTOR_IMAGE = "pgvector/pgvector:pg17";
 const DEFAULT_PGDOG_IMAGE = "ghcr.io/pgdogdev/pgdog:v0.1.51";
 const DEFAULT_KV_IMAGE = "redis:8-alpine";
-const DEFAULT_VAULT_IMAGE = "openbao/openbao:2.6.1";
 
 /**
- * Extract protocol id from a driver ref.
+ * Prefer `dev` then `prod` for a driver map (compose infra ≈ production).
  *
- * @param ref - String or `{ driver }` object
+ * @param map - Env driver input (normalized first)
  */
-function driverId(ref: DriverRef | undefined): string | undefined {
-  if (ref === undefined) return undefined;
-  return typeof ref === "string" ? ref : ref.driver;
-}
-
-/**
- * Prefer `docker` then `prod` for a driver map (compose infra ≈ production).
- *
- * @param map - Env driver map
- */
-function dockerOrProdId(
-  map: { readonly docker?: DriverRef; readonly prod?: DriverRef } | undefined,
-): string | undefined {
-  return driverId(map?.docker) ?? driverId(map?.prod);
+function dockerOrProdId(map: EnvDriverInput | undefined): string | undefined {
+  const normalized = normalizeEnvDriverMap(map);
+  return driverRefId(normalized?.dev) ?? driverRefId(normalized?.prod);
 }
 
 /**
@@ -75,11 +69,6 @@ export function defaultImagesFromConfig(config: OkeConfig): Readonly<Record<stri
     out["store.kv"] = DEFAULT_KV_IMAGE;
   }
 
-  const vault = dockerOrProdId(config.drivers?.vault);
-  if (vault === "openbao") {
-    out.vault = DEFAULT_VAULT_IMAGE;
-  }
-
   return out;
 }
 
@@ -89,6 +78,21 @@ export interface LoadedConfig {
   readonly path: string;
 }
 
+/**
+ * Reject removed env keys / drivers in `oke.config.*` source.
+ * Migration is documented — no soft-compat rewrite.
+ *
+ * @param source - File contents
+ */
+export function assertOkeConfigSource(source: string): void {
+  if (/(^|[^\w.])local\s*:/.test(source)) {
+    throw new Error(`"local" is no longer a valid environment key in oke.config.ts.`);
+  }
+  if (/(["'])sqlite\1/.test(source)) {
+    throw new Error(`"sqlite" is no longer a valid driver in oke.config.ts.`);
+  }
+}
+
 /**
  * Load `oke.config.ts` (or `.js` / `.mts`) from a directory.
  *
@@ -110,6 +114,8 @@ export async function loadOkeConfig(
   for (const path of candidates) {
     const file = Bun.file(path);
     if (!(await file.exists())) continue;
+    const source = await file.text();
+    assertOkeConfigSource(source);
     const mod = (await import(path)) as { default?: OkeConfig };
     if (!mod.default || typeof mod.default !== "object") {
       throw new Error(`oke: ${path} must default-export defineConfig({...})`);
@@ -174,14 +180,14 @@ export function dockerDevDriverMismatches(
 ): readonly StackDriverMismatch[] {
   const roles = new Set(stackRoles);
   const out: StackDriverMismatch[] = [];
-  const sqlDocker =
-    driverId(config.drivers?.store?.sql?.docker) ?? driverId(config.drivers?.store?.sql?.prod);
-  const kvDocker =
-    driverId(config.drivers?.store?.kv?.docker) ?? driverId(config.drivers?.store?.kv?.prod);
+  const sqlMap = normalizeEnvDriverMap(config.drivers?.store?.sql);
+  const kvMap = normalizeEnvDriverMap(config.drivers?.store?.kv);
+  const sqlDocker = driverRefId(sqlMap?.dev) ?? driverRefId(sqlMap?.prod);
+  const kvDocker = driverRefId(kvMap?.dev) ?? driverRefId(kvMap?.prod);
 
   if (
     roles.has("store.sql") &&
-    (sqlDocker === "sqlite" || sqlDocker === "memory" || sqlDocker === undefined)
+    (sqlDocker === "memory" || sqlDocker === "pglite" || sqlDocker === undefined)
   ) {
     out.push({
       label: "sql",

package/src/cli/meilisearch-local.ts

@@ -5,8 +5,7 @@
  * opts into the `meilisearch` store.index driver. This module:
  *
  *  - generates the master key once and persists it under `.oke/meilisearch/`
- *    (`0700` dir / `0600` file, atomic write — same material discipline as
- *    OpenBao, minus the init/unseal ceremony: a single static key),
+ *    (`0700` dir / `0600` file, atomic write — a single static key),
  *  - resolves the `meilisearch` binary from `PATH` (a documented prerequisite,
  *    like Docker for `--docker`; we never auto-download binaries),
  *  - spawns it via `Bun.spawn` with its own data dir + port, polls `/health`,

package/src/cli/mode.ts

@@ -1,65 +1,14 @@
 /**
- * `oke mode [local|docker]` — read or set the saved `oke dev` preference.
- * Setting a mode also syncs domain schema for that env (emit + push).
+ * `oke mode` — removed. `oke dev` always uses Docker Compose.
  */
 
-import { parseDevMode, readDevMode, writeDevMode, type DevMode } from "./dev-mode.ts";
-import { sqlDialectForEnv, syncDevSchema } from "./dev-schema-sync.ts";
-import { loadOkeConfig } from "./load-config.ts";
-
 /**
- * CLI entry for `oke mode`.
+ * CLI entry for deprecated `oke mode`.
  *
- * @param args - Args after `mode`
+ * @param _args - Ignored
  */
-export async function modeCli(args: readonly string[]): Promise<number> {
-  const cwd = process.cwd();
-  for (const a of args) {
-    if (a === "--help" || a === "-h") {
-      console.log(`oke mode [local|docker]
-
-Get or set the default infrastructure mode for \`oke dev\`
-(saved in .oke/mode). Setting a mode syncs domain schema for that env:
-emits schema.generated.ts for the active dialect, then runs \`oke db push\`.
-Data planes stay isolated — switching modes never copies rows.
-Session flags \`oke dev --local\` / \`oke dev --docker\` never change this
-preference.
-`);
-      return 0;
-    }
-  }
-
-  const positional = args.filter((a) => !a.startsWith("-"));
-  if (positional.length === 0) {
-    const saved = await readDevMode(cwd);
-    if (saved === null) {
-      console.log("oke mode: unset (default local until chosen)");
-      return 0;
-    }
-    console.log(saved);
-    return 0;
-  }
-
-  const next = parseDevMode(positional[0]);
-  if (next === null) {
-    console.error(`oke mode: expected local|docker, got ${JSON.stringify(positional[0])}`);
-    return 1;
-  }
-  await writeDevMode(cwd, next satisfies DevMode);
-
-  try {
-    const result = await syncDevSchema(cwd, next);
-    console.log(`oke mode: saved ${next} · dialect ${result.dialect}`);
-    return result.code;
-  } catch (err) {
-    const loaded = await loadOkeConfig(cwd).catch(() => null);
-    const dialect = loaded?.config
-      ? sqlDialectForEnv(loaded.config, next).dialect
-      : next === "docker"
-        ? "postgresql"
-        : "sqlite";
-    console.error(`oke mode: saved ${next} · dialect ${dialect}`);
-    console.error(err instanceof Error ? err.message : String(err));
-    return 1;
-  }
+export async function modeCli(_args: readonly string[]): Promise<number> {
+  void _args;
+  console.error("oke mode was removed — `oke dev` always uses Docker Compose");
+  return 1;
 }