okengine 0.19.8 → 0.20.0

package/site/content/docs/reference/plugins.mdx

@@ -54,7 +54,7 @@ export const app = oke({ name: "shop", env: "dev" }).plug(audit);
 <Step>
 ### Everything derives as usual
 
-Plugin flows appear in the Manifest, plugin tables land in `schema.drizzle.ts` on the next `oke db push`, plugin panels show up in the Console. No extra wiring — a contribution is ordinary OKE, just authored elsewhere.
+Plugin flows appear in the Manifest, plugin tables land in `src/db/drizzle/` on the next `oke db push`, plugin panels show up in the Console. No extra wiring — a contribution is ordinary OKE, just authored elsewhere.
 
 </Step>
 
@@ -76,8 +76,8 @@ Every method below exists on both the fluent definition and the boot-time builde
 | `.clock(decl)`                   | A named clock schedule — merged into boot clocks                                              |
 | `.signal(decl)`                  | A signal declaration — merged into boot signals                                               |
 | `.gate(decl)`                    | A gate declaration — merged into boot gates                                                   |
-| `.channelTemplate(decl)`         | A channel template — merged into boot channel templates                                       |
-| `.channelCatalog(catalog)`       | Template body catalog entries — merged into boot channel catalog (`{{field}}` interpolation)  |
+| `.channelTemplate(decl)`         | `channel.<medium>().template(…)` — `catalog` on the decl drains into boot                     |
+| `.channelCatalog(catalog)`       | Overlay bodies after `.template({ catalog })` (`{{field}}`); later locale wins                |
 | `.driver(id, impl)`              | A protocol-named driver for an existing element                                               |
 | `.image(role, recipe)`           | An image recipe for a docker role                                                             |
 | `.table(name, columns, options)` | A whole DB table, merged into the generated schema (`options.description` / `plane` optional) |
@@ -226,7 +226,7 @@ Extending an existing **app-owned** table with plugin columns is not supported i
     two configurations of one plugin would silently diverge. Pass identical config, or rename one
     instance.
   </Accordion>
-  <Accordion title="My plugin table is missing from schema.drizzle.ts">
+  <Accordion title="My plugin table is missing from drizzle/">
     The CLI reads table contributions from the live app entry. Make sure the plugin is actually
     `.plug()`ed in `src/app.ts` (or `db.entry` if overridden), then re-run `oke db push`.
   </Accordion>

package/site/content/docs/understand/try-it.mdx

@@ -21,6 +21,8 @@ cd my-app
 bun run dev
 ```
 
+Default is `-t blank` (health + Store/Vault). `-t shorter` is a URL shortener (`POST /links`, `GET /:code`).
+
 Open the Console at the address printed in the terminal and claim it with the code shown there. The Flows listed weren't configured anywhere — they were derived from the code you just scaffolded.
 
 ## Call it

package/src/cli/ai-setup/ai-setup.test.ts

@@ -464,6 +464,46 @@ export default defineConfig({
     }
   });
 
+  test("applyAiSetup writes src/core/ai.ts when the barrel is src/core/index.ts", () => {
+    const dir = mkdtempSync(join(tmpdir(), "oke-ai-setup-index-"));
+    try {
+      writeFileSync(
+        join(dir, "oke.config.ts"),
+        `import { defineConfig } from "okengine/config";
+export default defineConfig({
+  drivers: {
+    channel: { email: { dev: "console", test: "console", prod: "console" } },
+  },
+});
+`,
+        "utf8",
+      );
+      mkdirSync(join(dir, "src", "core"), { recursive: true });
+      writeFileSync(join(dir, "src", "core", "index.ts"), `export * from "./store.ts";\n`, "utf8");
+      writeFileSync(
+        join(dir, "src", "app.ts"),
+        `import "@/core";\nexport const app = {};\n`,
+        "utf8",
+      );
+
+      applyAiSetup(dir, {
+        driver: "openai-compatible",
+        provider: "openrouter",
+        chatModel: "openrouter/free",
+      });
+
+      const index = readFileSync(join(dir, "src", "core", "index.ts"), "utf8");
+      expect(index).not.toContain("ai.model");
+      expect(index).toContain('export * from "./ai.ts"');
+      const aiTs = readFileSync(join(dir, "src", "core", "ai.ts"), "utf8");
+      expect(aiTs).toContain("smart");
+      const app = readFileSync(join(dir, "src", "app.ts"), "utf8");
+      expect(app).not.toContain("./core/ai");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
   test("applyAiSetup writes API token to .env.local and vault.secret into core", () => {
     const dir = mkdtempSync(join(tmpdir(), "oke-ai-setup-key-"));
     try {

package/src/cli/ai-setup/apply.ts

@@ -434,8 +434,8 @@ export function ensureAiApiKeyVaultSecret(cwd: string, apiKeyEnv: string): void
 
 /**
  * Write AI model declarations into `src/core/ai.ts` when that split exists
- * (so a thin `src/core.ts` barrel stays a re-export), else `src/core.ts`,
- * else legacy `src/core/index.ts` + sidecar.
+ * (so a thin `src/core.ts` / `src/core/index.ts` barrel stays a re-export),
+ * else `src/core.ts`.
  *
  * @param cwd - Project root
  * @param input - Setup choices
@@ -445,25 +445,23 @@ function writeAiModels(cwd: string, input: AiSetupApplyInput): string {
   const rendered = renderAiTs(input);
   const coreAiPath = join(cwd, "src", "core", "ai.ts");
   const coreTsPath = join(cwd, "src", "core.ts");
-  const legacyIndex = join(cwd, "src", "core", "index.ts");
-
-  if (existsSync(coreAiPath)) {
-    const existing = readFileSync(coreAiPath, "utf8");
-    writeFileSync(coreAiPath, resolveAiCoreSource(existing, rendered), "utf8");
+  const coreIndexPath = join(cwd, "src", "core", "index.ts");
+  const splitLayout =
+    existsSync(coreAiPath) || (!existsSync(coreTsPath) && existsSync(coreIndexPath));
+
+  if (splitLayout) {
+    mkdirSync(dirname(coreAiPath), { recursive: true });
+    const existing = existsSync(coreAiPath) ? readFileSync(coreAiPath, "utf8") : "";
+    writeFileSync(
+      coreAiPath,
+      existing ? resolveAiCoreSource(existing, rendered) : rendered,
+      "utf8",
+    );
     ensureCoreBarrelExportsAi(cwd);
     ensureCoreImported(cwd);
     return coreAiPath;
   }
 
-  // Folder layout still in the wild — keep writing a sidecar.
-  if (!existsSync(coreTsPath) && existsSync(legacyIndex)) {
-    const aiTsPath = join(cwd, "src", "core", "ai.ts");
-    mkdirSync(dirname(aiTsPath), { recursive: true });
-    writeFileSync(aiTsPath, rendered, "utf8");
-    ensureLegacyAiImported(cwd);
-    return aiTsPath;
-  }
-
   mkdirSync(dirname(coreTsPath), { recursive: true });
   if (existsSync(coreTsPath)) {
     const existing = readFileSync(coreTsPath, "utf8");
@@ -625,16 +623,25 @@ export function ensureNamedOkengineImport(source: string, name: string): string
 }
 
 /**
- * Keep a `src/core.ts` barrel re-exporting `./core/ai.ts` after a split write.
+ * Keep a core barrel re-exporting the AI sidecar after a split write.
+ *
+ * `src/core.ts` → `./core/ai.ts`; `src/core/index.ts` → `./ai.ts`.
  *
  * @param cwd - Project root
  */
 function ensureCoreBarrelExportsAi(cwd: string): void {
   const coreTsPath = join(cwd, "src", "core.ts");
-  if (!existsSync(coreTsPath)) return;
-  const src = readFileSync(coreTsPath, "utf8");
-  if (/from\s+["']\.\/core\/ai/.test(src)) return;
-  writeFileSync(coreTsPath, `${src.trimEnd()}\nexport * from "./core/ai.ts";\n`, "utf8");
+  if (existsSync(coreTsPath)) {
+    const src = readFileSync(coreTsPath, "utf8");
+    if (/from\s+["']\.\/core\/ai(?:\.ts)?["']/.test(src)) return;
+    writeFileSync(coreTsPath, `${src.trimEnd()}\nexport * from "./core/ai.ts";\n`, "utf8");
+    return;
+  }
+  const coreIndexPath = join(cwd, "src", "core", "index.ts");
+  if (!existsSync(coreIndexPath)) return;
+  const src = readFileSync(coreIndexPath, "utf8");
+  if (/from\s+["']\.\/ai(?:\.ts)?["']/.test(src)) return;
+  writeFileSync(coreIndexPath, `${src.trimEnd()}\nexport * from "./ai.ts";\n`, "utf8");
 }
 
 /**
@@ -656,28 +663,3 @@ function ensureCoreImported(cwd: string): void {
   }
   writeFileSync(appPath, `import "@/core";\n${src}`, "utf8");
 }
-
-/**
- * Legacy `src/core/*` layout — side-effect import the AI sidecar.
- *
- * @param cwd - Project root
- */
-function ensureLegacyAiImported(cwd: string): void {
-  const candidates: ReadonlyArray<{ readonly rel: string; readonly importLine: string }> = [
-    { rel: "src/app.ts", importLine: `import "./core/ai";\n` },
-    { rel: "src/core/index.ts", importLine: `import "./ai";\n` },
-  ];
-  for (const { rel, importLine } of candidates) {
-    const path = join(cwd, rel);
-    if (!existsSync(path)) continue;
-    const src = readFileSync(path, "utf8");
-    if (
-      /from\s+["']\.\/(?:core\/)?ai["']/.test(src) ||
-      /import\s+["']\.\/(?:core\/)?ai["']/.test(src)
-    ) {
-      return;
-    }
-    writeFileSync(path, `${importLine}${src}`, "utf8");
-    return;
-  }
-}

package/src/cli/ask-vault-gaps.test.ts

@@ -2,11 +2,21 @@
  * Tests for interactive Vault gap fill during `oke dev`.
  */
 
-import { describe, expect, test } from "bun:test";
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { maybeAskVaultGaps } from "./ask-vault-gaps.ts";
+import { join, resolve } from "node:path";
+import { resetRequiredEnvNames, resetSecrets } from "../elements/vault/declare.ts";
+import { resetBindings } from "../kernel/on.ts";
+import { maybeAskVaultGaps, probeVaultGaps } from "./ask-vault-gaps.ts";
+
+const OKE = resolve(import.meta.dir, "../index.ts");
+
+afterEach(() => {
+  resetBindings();
+  resetSecrets();
+  resetRequiredEnvNames();
+});
 
 describe("maybeAskVaultGaps", () => {
   test("skips when non-TTY", async () => {
@@ -82,3 +92,49 @@ describe("maybeAskVaultGaps", () => {
     }
   });
 });
+
+describe("probeVaultGaps", () => {
+  test("sees secrets on oke({ secrets }) after consume drains the registry", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "probe-vault-"));
+    const name = `PROBE_GAP_${crypto.randomUUID().replaceAll("-", "_")}`;
+    try {
+      writeFileSync(
+        join(dir, "app.ts"),
+        `
+import { oke, vault } from ${JSON.stringify(OKE)};
+export const key = vault.secret(${JSON.stringify(name)}, {
+  description: "probe gap",
+});
+export const app = oke({
+  name: "probe-vault",
+  autoBoot: false,
+  secrets: [key],
+});
+`,
+      );
+      const gaps = await probeVaultGaps(dir, "app.ts");
+      expect(gaps.map((g) => g.name)).toContain(name);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("sees auto-registered vault.secret after oke() consume", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "probe-vault-auto-"));
+    const name = `PROBE_AUTO_${crypto.randomUUID().replaceAll("-", "_")}`;
+    try {
+      writeFileSync(
+        join(dir, "app.ts"),
+        `
+import { oke, vault } from ${JSON.stringify(OKE)};
+vault.secret(${JSON.stringify(name)}, { description: "auto registry gap" });
+export const app = oke({ name: "probe-vault-auto", autoBoot: false });
+`,
+      );
+      const gaps = await probeVaultGaps(dir, "app.ts");
+      expect(gaps.map((g) => g.name)).toContain(name);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/cli/ask-vault-gaps.ts

@@ -9,8 +9,10 @@ import { resolve } from "node:path";
 import { resolveDriverId } from "../config/index.ts";
 import { VAULT_DEFAULTS } from "../config/driver-defaults.ts";
 import { resolveAppEntryForPluginTables } from "../elements/store/load-plugin-tables.ts";
+import type { VaultSecretDecl } from "../elements/vault/declare.ts";
 import { buildVaultBootChain, normalizeVaultDriverId } from "../elements/vault/boot-chain.ts";
 import { createVaultRuntime, VaultBootError, type VaultGap } from "../elements/vault/runtime.ts";
+import type { OkeOptions } from "../kernel/app.ts";
 import { requiredEnvRegistry, secretRegistry } from "../kernel/element-registries.ts";
 import { formatCliChrome } from "../term.ts";
 import { loadOkeConfig } from "./load-config.ts";
@@ -43,6 +45,10 @@ export interface AskVaultGapsOptions {
 /**
  * Probe Vault contracts declared by the app entry and return boot gaps.
  *
+ * `oke()` drains `secretRegistry` at construction (`registry: "consume"`),
+ * so the probe reads `app.$options.secrets` — the same list boot uses —
+ * and unions any leftovers still on the module-evaluation registries.
+ *
  * @param cwd - Project root
  * @param entry - Optional entry override
  */
@@ -54,9 +60,12 @@ export async function probeVaultGaps(cwd: string, entry?: string): Promise<reado
   try {
     const entryAbs = await resolveAppEntryForPluginTables(cwd, entry);
     if (!entryAbs) return [];
-    await import(entryAbs);
-    const secrets = secretRegistry.slice();
-    const requiredEnv = requiredEnvRegistry.slice();
+    const mod = (await import(entryAbs)) as Record<string, unknown>;
+    const fromApp = vaultProbeContracts(mod);
+    const secrets = unionSecrets(fromApp?.secrets ?? [], secretRegistry.slice());
+    const requiredEnv = [
+      ...new Set([...(fromApp?.requiredEnv ?? []), ...requiredEnvRegistry.slice()]),
+    ];
     if (secrets.length === 0 && requiredEnv.length === 0) return [];
 
     const loaded = await loadOkeConfig(cwd).catch(() => null);
@@ -91,6 +100,53 @@ export async function probeVaultGaps(cwd: string, entry?: string): Promise<reado
   }
 }
 
+/**
+ * Contracts the imported `oke()` app will boot with (`$options.secrets` /
+ * `vault.requiredEnv`). Undefined when the module has no bootable app.
+ *
+ * @param mod - Imported entry namespace
+ */
+function vaultProbeContracts(mod: Record<string, unknown>):
+  | {
+      readonly secrets: readonly VaultSecretDecl[];
+      readonly requiredEnv: readonly string[];
+    }
+  | undefined {
+  for (const key of ["app", "default", ...Object.keys(mod)]) {
+    const value = mod[key];
+    if (!value || typeof value !== "object") continue;
+    const boot = (value as { boot?: unknown }).boot;
+    const options = (value as { $options?: OkeOptions }).$options;
+    if (typeof boot !== "function" || options === undefined) continue;
+    return {
+      secrets: options.secrets ?? [],
+      requiredEnv: options.vault?.requiredEnv ?? [],
+    };
+  }
+  return undefined;
+}
+
+/**
+ * Concat secret lists, skipping later entries that share a contract name.
+ *
+ * @param primary - App `$options.secrets` (boot source of truth)
+ * @param extra - Registry leftovers (`registry: "ignore"` / no `oke()` export)
+ */
+function unionSecrets(
+  primary: readonly VaultSecretDecl[],
+  extra: readonly VaultSecretDecl[],
+): VaultSecretDecl[] {
+  const out: VaultSecretDecl[] = [...primary];
+  const names = new Set(primary.map((secret) => secret.name));
+  for (const secret of extra) {
+    if (!names.has(secret.name)) {
+      names.add(secret.name);
+      out.push(secret);
+    }
+  }
+  return out;
+}
+
 /**
  * After compose hydrate (and usually schema push), fill Vault boot gaps
  * one-by-one into `.env.local`. Skips when non-TTY or no gaps.

package/src/cli/build.test.ts

@@ -1,5 +1,5 @@
 /**
- * `oke build` regenerates `src/flows/generated.ts` before bundling — real
+ * `oke build` regenerates `src/flows/index.ts` before bundling — real
  * before/after proof, not an assumption about the wiring.
  */
 
@@ -16,13 +16,13 @@ async function makeUnit(root: string, name: string): Promise<void> {
 }
 
 describe("oke build — .adopt() barrel regeneration", () => {
-  test("real before/after: no generated.ts before build, real barrel content after", async () => {
+  test("real before/after: no index.ts before build, real barrel content after", async () => {
     const root = await mkdtemp(join(tmpdir(), "oke-build-adopt-"));
     try {
       await makeUnit(root, "main");
       await makeUnit(root, "notes");
 
-      const generatedPath = join(root, "src/flows/generated.ts");
+      const generatedPath = join(root, "src/flows/index.ts");
       await expect(readFile(generatedPath, "utf8")).rejects.toThrow();
 
       const code = await runBuild({

package/src/cli/build.ts

@@ -18,16 +18,16 @@ export interface BuildOptions {
   }) => Promise<{ success: boolean; logs: string }>;
   /**
    * Inject `.adopt()` barrel regeneration (tests). Default: real
-   * `generateAdoptBarrel` + atomic write to `<rootDir>/src/flows/generated.ts`
-   * (`generated.ts.tmp` → rename). Returns the unit names written, for the
+   * `generateAdoptBarrel` + atomic write to `<rootDir>/src/flows/index.ts`
+   * (`index.ts.tmp` → rename). Returns the unit names written, for the
    * status line.
    */
   readonly syncAdoptBarrel?: (rootDir: string) => Promise<readonly string[]>;
 }
 
 /**
- * Regenerate `src/flows/generated.ts` from every `src/flows/<unit>/index.ts`
- * unit folder — pre-step for `oke build` (mirrors `oke db`'s `schema.drizzle.ts`
+ * Regenerate `src/flows/index.ts` from every `src/flows/<unit>/` folder —
+ * pre-step for `oke build` (mirrors `oke db`'s `drizzle/`
  * pre-step). A real file on disk, not a virtual module: identical resolution
  * under `oke dev`'s runtime `import()` and `oke build`'s `Bun.build()`
  * (investigated — a virtual-module Bun plugin does not resolve consistently
@@ -76,7 +76,7 @@ export async function runBuild(options: BuildOptions = {}): Promise<number> {
   try {
     const units = await syncAdoptBarrel(rootDir);
     write(
-      `oke build: .adopt() barrel → src/flows/generated.ts (${units.length} unit${units.length === 1 ? "" : "s"})\n`,
+      `oke build: .adopt() barrel → src/flows/index.ts (${units.length} unit${units.length === 1 ? "" : "s"})\n`,
     );
     const result = await bundle({ entry, outdir, target: bunTarget });
     if (!result.success) {

package/src/cli/db-auto-push.test.ts

@@ -17,7 +17,18 @@ describe("isDomainSchemaWatchPath", () => {
     expect(isDomainSchemaWatchPath("src/schema.decl.ts")).toBe(true);
   });
 
+  test("matches split declare modules under schema/", () => {
+    expect(isDomainSchemaWatchPath("db/schema/links.ts")).toBe(true);
+    expect(isDomainSchemaWatchPath("src/db/schema/daily.ts")).toBe(true);
+    expect(isDomainSchemaWatchPath("src/db/schema/index.ts")).toBe(true);
+    expect(isDomainSchemaWatchPath("src/db/schema/relations.ts")).toBe(true);
+  });
+
   test("ignores emit output (avoids push ↔ generated feedback loop)", () => {
+    expect(isDomainSchemaWatchPath("src/db/drizzle.ts")).toBe(false);
+    expect(isDomainSchemaWatchPath("drizzle.ts")).toBe(false);
+    expect(isDomainSchemaWatchPath("src/db/drizzle/index.ts")).toBe(false);
+    expect(isDomainSchemaWatchPath("src/db/drizzle/links.ts")).toBe(false);
     expect(isDomainSchemaWatchPath("src/db/schema.drizzle.ts")).toBe(false);
     expect(isDomainSchemaWatchPath("schema.drizzle.ts")).toBe(false);
     expect(isDomainSchemaWatchPath("flows/notes/schema.drizzle.tsx")).toBe(false);

package/src/cli/db-auto-push.ts

@@ -11,8 +11,8 @@ export const DB_AUTO_PUSH_DEBOUNCE_MS = 300;
  * Whether a watched path should trigger `oke db push`.
  *
  * Inputs only: declaration / drizzle config / app entry. Never the emit
- * output (`schema.drizzle.ts`) — push rewrites that file every run, so
- * watching it loops `oke db push` forever under `oke dev`.
+ * output (`src/db/drizzle/`) — push rewrites those files every run, so
+ * watching them loops `oke db push` forever under `oke dev`.
  *
  * @param filename - Relative path from the watcher (may be undefined)
  */
@@ -21,8 +21,10 @@ export function isDomainSchemaWatchPath(filename: string | null | undefined): bo
   const normalized = filename.replace(/\\/g, "/");
   const base = basename(normalized);
   // Emit output — never a watch trigger (feedback loop with `oke db push`).
+  if (base === "drizzle.ts" || base === "drizzle.tsx") return false;
   if (base === "schema.drizzle.ts" || base === "schema.drizzle.tsx") return false;
   if (base === "schema.generated.ts" || base === "schema.generated.tsx") return false;
+  if (/(^|\/)drizzle\/.+\.tsx?$/.test(normalized)) return false;
   if (base === "schema.ts" || base === "schema.tsx") return true;
   if (base === "schema.decl.ts" || base === "schema.decl.tsx") return true;
   if (base === "drizzle.config.ts" || base === "drizzle.config.js") return true;
@@ -30,6 +32,8 @@ export function isDomainSchemaWatchPath(filename: string | null | undefined): bo
   if (base === "app.ts" || base === "app.tsx") return true;
   // Nested domain schemas commonly live under src/**/schema.ts (not emit output).
   if (/(^|\/)schema(\.decl)?\.tsx?$/.test(normalized)) return true;
+  // Split declare modules: `src/db/schema/links.ts` next to `schema/index.ts`.
+  if (/(^|\/)schema\/.+\.tsx?$/.test(normalized)) return true;
   return false;
 }
 

package/src/cli/db.test.ts

@@ -327,7 +327,7 @@ export const app = oke({ name: "plugin-only" }).plug(
     const emitted = await emitAbstractSchemaPrestep(dir, loaded.config, () => {}, "test");
     expect(emitted).toBe(true);
 
-    const generated = await readFile(join(dir, "src", "db", "schema.drizzle.ts"), "utf8");
+    const generated = await readFile(join(dir, "src", "db", "drizzle", "metrics_daily.ts"), "utf8");
     expect(generated).toContain('pgTable("metrics_daily"');
     // Postgres dialect maps abstract integer → bigint (32-bit INTEGER is too narrow).
     expect(generated).toContain('bigint("hits", { mode: "number" })');

package/src/cli/db.ts

@@ -3,8 +3,8 @@
  * plus explicit seed runs.
  *
  * Distinct from `oke schema generate` (core/plugin stub tables).
- * When abstract decls exist (`src/db/schema.decl.ts`), emits Drizzle first —
- * not a third schema CLI.
+ * When abstract decls exist (`src/db/schema.ts` or `src/db/schema/index.ts`),
+ * emits Drizzle first — not a third schema CLI.
  */
 
 import { resolve } from "node:path";
@@ -279,7 +279,7 @@ export async function runDb(sub: DbSubcommand, options: DbOptions = {}): Promise
 }
 
 /**
- * Emit `schema.drizzle.ts` from abstract decls + live plugged plugin tables.
+ * Emit `drizzle/` from abstract decls + live plugged plugin tables.
  *
  * @param cwd - Project root
  * @param config - Loaded oke config
@@ -596,9 +596,9 @@ export async function dbCli(args: readonly string[]): Promise<number> {
     console.log(`oke db push|generate|migrate|seed|studio|search-backfill [--config|-c] [--env name] [--force]
 
 Domain schema sync via drizzle-kit, plus explicit seed and hybrid-search backfill.
-When src/db/schema.decl.ts and/or a plugged app entry exists, emits
-schema.drizzle.ts from store.schema.table + live plugin .table()
-contributions — then runs drizzle-kit.
+When src/db/schema.ts or src/db/schema/index.ts and/or a plugged app
+entry exists, emits src/db/drizzle/ from store.schema.table + live plugin
+.table() contributions — then runs drizzle-kit.
 Hand-written src/schema.ts remains supported (emit skipped if nothing to emit).
 Not the same as \`oke schema generate\` (core/plugin stub tables).
 

package/src/cli/dev-app-runner.ts

@@ -81,10 +81,18 @@ if (
   process.exit(1);
 }
 
-await mod.app.boot({
-  rootDir: process.env["OKE_ROOT_DIR"],
-  ...(manifest !== undefined ? { manifest } : {}),
-});
+try {
+  await mod.app.boot({
+    rootDir: process.env["OKE_ROOT_DIR"],
+    ...(manifest !== undefined ? { manifest } : {}),
+  });
+} catch (err) {
+  // `bun --hot` keeps the watcher alive on an uncaught throw, so `oke dev`
+  // would wait the full ready timeout after VaultBootError. Exit so the
+  // parent sees a dead child immediately.
+  console.error(err);
+  process.exit(1);
+}
 const handle = createBunRuntime().serve(mod.app, {
   port,
   hostname,

package/src/cli/dev-db-push.test.ts

@@ -169,7 +169,7 @@ export const entries = pgTable("entries", {
     expect(pushes.length).toBeGreaterThan(before);
   });
 
-  test("schema.drizzle.ts change does not re-trigger dbPush", async () => {
+  test("generated drizzle.ts change does not re-trigger dbPush", async () => {
     const cwd = await scaffoldProject();
     const pushes: string[] = [];
     const watcher = controlledWatcher();
@@ -221,7 +221,11 @@ export const entries = pgTable("entries", {
     const before = pushes.length;
     expect(before).toBeGreaterThanOrEqual(1);
 
-    // Simulate emit writing schema.drizzle.ts after push — must not loop.
+    // Simulate emit writing drizzle.ts after push — must not loop.
+    watcher.change("drizzle.ts");
+    watcher.change("src/db/drizzle.ts");
+    watcher.change("src/db/drizzle/index.ts");
+    watcher.change("src/db/drizzle/links.ts");
     watcher.change("schema.drizzle.ts");
     watcher.change("src/db/schema.drizzle.ts");
     watcher.change("schema.generated.ts");

package/src/cli/dev-schema-sync.ts

@@ -25,7 +25,7 @@ import { loadOkeConfig, resolveImages } from "./load-config.ts";
 export interface DevSchemaSyncOptions {
   /** Write output (default: stdout). */
   readonly write?: (text: string) => void;
-  /** Skip emitting `schema.drizzle.ts` (tests). */
+  /** Skip emitting `drizzle/` (tests). */
   readonly skipEmit?: boolean;
   /** Injectable push (tests). Default: `runDb("push", ...)`. */
   readonly pushFn?: (cwd: string, env: ConfigEnv) => Promise<number>;

package/src/cli/dev.test.ts

@@ -706,7 +706,7 @@ describe("oke dev hot reload", () => {
 });
 
 describe("oke dev syncAdoptBarrel atomic write", () => {
-  test("default path regenerates generated.ts and leaves no .tmp behind", async () => {
+  test("default path regenerates index.ts and leaves no .tmp behind", async () => {
     const dir = await mkdtemp(join(tmpdir(), "oke-dev-adopt-atomic-"));
     await mkdir(join(dir, "src/flows/notes"), { recursive: true });
     await Bun.write(join(dir, "src/flows/notes/index.ts"), "export {};\n");
@@ -791,9 +791,12 @@ describe("oke dev syncAdoptBarrel atomic write", () => {
 });
 
 describe("isFlowsTreeWatchPath", () => {
-  test("flows tree files trigger regen; generated.ts does not", () => {
+  test("flows tree files trigger regen; adopt barrel does not", () => {
     expect(isFlowsTreeWatchPath("flows/notes/[id]/get.ts")).toBe(true);
     expect(isFlowsTreeWatchPath("flows\\notes\\list.ts")).toBe(true);
+    expect(isFlowsTreeWatchPath("flows/notes/index.ts")).toBe(true);
+    expect(isFlowsTreeWatchPath("flows/index.ts")).toBe(false);
+    expect(isFlowsTreeWatchPath("flows/index.ts.tmp")).toBe(false);
     expect(isFlowsTreeWatchPath("flows/generated.ts")).toBe(false);
     expect(isFlowsTreeWatchPath("flows/generated.ts.tmp")).toBe(false);
     expect(isFlowsTreeWatchPath("core.ts")).toBe(false);
@@ -953,7 +956,7 @@ describe("oke dev Docker-first", () => {
   });
 });
 
-describe("oke dev schema.decl sync framing", () => {
+describe("oke dev schema declare sync framing", () => {
   let session: DevSession | undefined;
 
   afterEach(() => {
@@ -981,7 +984,7 @@ describe("oke dev schema.decl sync framing", () => {
     await Bun.write(join(dir, "src/app.ts"), "export {}\n");
     // Genuine definition error: `.references()` target is undefined → emit throws.
     await Bun.write(
-      join(dir, "src/db/schema.decl.ts"),
+      join(dir, "src/db/schema.ts"),
       `import { store, field } from ${JSON.stringify(OKE_INDEX)};
 
 export const authors = store.schema.table("authors", {
@@ -1024,8 +1027,8 @@ export const posts = store.schema.table("posts", {
     session = result.session;
 
     const plain = writes.join("").replace(/\x1b\[[0-9;]*m/g, "");
-    expect(plain).toContain("schema.decl.ts has an error");
-    expect(plain).toMatch(/●\s*schema\.decl\.ts has an error/);
+    expect(plain).toContain("schema.ts has an error");
+    expect(plain).toMatch(/●\s*schema\.ts has an error/);
     expect(plain).not.toContain("oke db push (dev) skipped");
   }, 60_000);
 
@@ -1065,7 +1068,7 @@ export const posts = store.schema.table("posts", {
 
     const plain = writes.join("").replace(/\x1b\[[0-9;]*m/g, "");
     expect(plain).toContain("oke db push (dev) skipped — docker mode: oke.config.ts not found");
-    expect(plain).not.toContain("schema.decl.ts has an error");
+    expect(plain).not.toContain("schema.ts has an error");
   }, 60_000);
 });