okengine 0.19.9 → 0.21.0

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/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

@@ -90,7 +90,8 @@ try {
   // `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);
+  const { formatFatalError } = await import("../term.ts");
+  console.error(formatFatalError(err));
   process.exit(1);
 }
 const handle = createBunRuntime().serve(mod.app, {

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);
 });
 

package/src/cli/dev.ts

@@ -27,6 +27,7 @@ import {
   writeStackCredentialsCache,
   type DeriveOptions,
 } from "../docker/index.ts";
+import { isAdoptBarrelRelPath } from "../compiler/generate-adopt.ts";
 import type { Manifest } from "../manifest/types.ts";
 import type { McpContext } from "../mcp/tools.ts";
 import { APP_PORT, CONSOLE_PORT, DOCS_MCP_PORT, MCP_PORT } from "../runtime/types.ts";
@@ -183,9 +184,9 @@ export interface DevOptions {
   readonly onDbAutoPush?: (filename: string) => void;
   /**
    * Injectable `.adopt()` barrel regeneration (tests). Default: real
-   * `generateAdoptBarrel` + atomic write to `<cwd>/src/flows/generated.ts`
-   * (`generated.ts.tmp` → rename). Runs at session start and again on
-   * `src/flows/**` changes except `generated.ts` itself. Write-if-changed
+   * `generateAdoptBarrel` + atomic write to `<cwd>/src/flows/index.ts`
+   * (`index.ts.tmp` → rename). Runs at session start and again on
+   * `src/flows/**` changes except `index.ts` itself. Write-if-changed
    * so the `src/` watcher + bun `--hot` do not loop.
    *
    * @param cwd - Project root
@@ -370,7 +371,7 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
   const cwd = options.cwd ?? process.cwd();
 
   // One-shot `.adopt()` barrel regen for the session — real file on disk
-  // (`src/flows/generated.ts`), written atomically (tmp → rename) before the
+  // (`src/flows/index.ts`), written atomically (tmp → rename) before the
   // entry is resolved/imported below so a freshly-added flows unit is
   // adoptable without a hand edit. Best-effort like `syncDevSchema` below:
   // a project with no `src/flows` yet (or a synthetic test tree) never
@@ -1036,7 +1037,7 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
   }
 
   // One-shot schema sync for the compose (`dev`) profile: emits
-  // schema.drizzle.ts for the active dialect, then pushes via drizzle-kit.
+  // drizzle/ for the active dialect, then pushes via drizzle-kit.
   let schemaPushOk = options.noDbPush === true;
   if (!options.noDbPush) {
     const { syncDevSchema } = await import("./dev-schema-sync.ts");
@@ -1576,7 +1577,7 @@ function isBenignDevSchemaEnvSkip(message: string): boolean {
 }
 
 /**
- * Whether a caught sync/push error is a schema.decl definition failure
+ * Whether a caught sync/push error is a schema declare definition failure
  * (import evaluation, emit, duplicate tables, bad `.references()`, …).
  *
  * Message text alone is insufficient — emit-time bugs often look like bare
@@ -1584,7 +1585,7 @@ function isBenignDevSchemaEnvSkip(message: string): boolean {
  * emit frames.
  *
  * @param err - Caught value
- * @param declarePath - Resolved schema.decl path for this project
+ * @param declarePath - Resolved schema declare path for this project
  */
 function isSchemaDeclDefinitionError(err: unknown, declarePath: string): boolean {
   const msg = err instanceof Error ? err.message : String(err);
@@ -1600,15 +1601,15 @@ function isSchemaDeclDefinitionError(err: unknown, declarePath: string): boolean
 
 /**
  * True when a `src/` watcher event is a flows tree change that should
- * regenerate `generated.ts` (never the generated file itself).
+ * regenerate `src/flows/index.ts` (never the barrel itself, nor a leftover
+ * `generated.ts`). Unit `index.ts` files still trigger regen.
  *
  * @param rel - Watcher filename (POSIX or Windows)
  */
 export function isFlowsTreeWatchPath(rel: string): boolean {
   const posix = rel.replace(/\\/g, "/");
   if (!posix.includes("flows/")) return false;
-  const base = posix.split("/").pop() ?? posix;
-  if (base === "generated.ts" || base === "generated.ts.tmp") return false;
+  if (isAdoptBarrelRelPath(posix)) return false;
   return true;
 }
 
@@ -1638,7 +1639,8 @@ async function formatDevSchemaSyncFailure(
   const { resolveEmitPaths } = await import("../elements/store/emit-drizzle.ts");
   const { declarePath } = resolveEmitPaths(cwd);
   if (isSchemaDeclDefinitionError(err, declarePath)) {
-    return formatStatusLine(`schema.decl.ts has an error — ${msg}`, color, "error");
+    const declareName = declarePath.split(/[/\\]/).pop() ?? "schema.ts";
+    return formatStatusLine(`${declareName} has an error — ${msg}`, color, "error");
   }
 
   const label = context === "watch" ? "oke db push (schema change)" : "oke db push (dev)";

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

@@ -12,8 +12,9 @@ const DRIZZLE_CONFIG_TEMPLATE = `import { defineConfig } from "drizzle-kit";
  * Domain schema sync for \`oke db push|generate|migrate\`.
  *
  * 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\`).
+ * \`src/db/schema.ts\` (single file) or \`src/db/schema/index.ts\`
+ * (folder) → \`src/db/drizzle/\` (emitted as a pre-step of \`oke db\` /
+ * \`oke dev\`). \`schema.ts\` wins when both exist.
  *
  * System / auth / plugin stubs are separate: \`oke schema generate\` →
  * \`.oke/schema/oke.ts\` (gitignored with \`.oke/\`). Re-run after adding plugins.
@@ -22,7 +23,7 @@ const DRIZZLE_CONFIG_TEMPLATE = `import { defineConfig } from "drizzle-kit";
  */
 export default defineConfig({
   dialect: "postgresql",
-  schema: "./src/db/schema.drizzle.ts",
+  schema: "./src/db/drizzle/index.ts",
   out: "./src/db/migrations",
   // Domain tables live in public. Schema \`oke\` (RLS) and \`oke_console\` are engine-owned.
   schemaFilter: ["public"],

package/src/cli/start.ts

@@ -4,6 +4,7 @@
 
 import { resolve } from "node:path";
 import { APP_PORT } from "../runtime/types.ts";
+import { formatFatalError } from "../term.ts";
 
 /** Options for {@link runStart}. */
 export interface StartOptions {
@@ -77,7 +78,7 @@ export async function runStart(options: StartOptions = {}): Promise<number> {
     await import(entry);
     return 0;
   } catch (err) {
-    console.error(err instanceof Error ? err.message : String(err));
+    console.error(formatFatalError(err));
     return 1;
   }
 }

package/src/client/create.ts

@@ -194,14 +194,14 @@ export function flattenRoutes(
 function proxy(transport: Transport, path: readonly string[], ctx: ProxyCtx): unknown {
   const invoke = async (input?: unknown, callOpts?: CallOpts): Promise<ClientResult> => {
     if (path.length < 2) {
+      const message = `Incomplete path: api.${path.join(".") || "?"}(…)`;
       return attachPager(
         {
           data: null,
           error: {
             code: "TransportError" as const,
-            data: {
-              message: `Incomplete path: api.${path.join(".") || "?"}(…)`,
-            },
+            message,
+            data: { message },
           },
         },
         (nextInput) => invoke(nextInput, callOpts),