@@ -31,6 +31,23 @@ here.**
 - **SQLite: a function-call column default is wrapped in parentheses** when emitted, as SQLite
   requires (`DEFAULT (expr)`). Before, an authored expression default such as
   `datetime('now')` produced a `CREATE TABLE` that did not parse.
+- **`meta init`'s config passes its own typecheck.** `extStyle` was required by the config
+  type but absent from the scaffolded `metaobjects.config.ts`, so
+  `npx tsc -p tsconfig.codegen.json --noEmit` failed with `Property 'extStyle' is missing`
+  on a fresh project. It is optional now and defaults to `"js"`, which every generator
+  already assumed.
+- **`dbImport` is demanded only by a generator whose output imports `db`.** The reference
+  `entity`, `routes` and `routes-hono` generators (the copies `meta eject` hands over) copy
+  the render context with an object spread, and the demand fired on that read, so
+  `meta eject entity` alone failed with `codegen config is missing dbImport` in a project
+  whose queries take `db` as a parameter. The runner now checks the emitted output instead,
+  which also fixes copies already ejected.
+- **A new database is pointed at `meta migrate apply-pending`.** `meta init`'s next steps
+  name it, and `meta migrate --db <url> --apply` against an empty database with committed
+  migrations now says to replay them rather than only asking for `--slug`.
+- **`meta verify` names the prompt file it could not find.** `ERR_PARTIAL_UNRESOLVED` now
+  says which file to create (`prompts/<ref>.mustache` or `.txt`) and that `--prompts` moves
+  the root, instead of only naming the directory it searched.
 - **Agent context: hand-built LLM prompts** (#389). The always-on context installed by
   `meta init` gains a rule: once a project declares any `template.prompt`, every LLM prompt is
   one, replies are read through a response model, and changing a hand-built prompt means
 
@@ -157,6 +157,8 @@ Next steps:
   4. meta gen                  # generate from exactly what you wired
   5. meta docs                  # neutral model + API docs (on by default)
   6. Create your tables: meta migrate --from-db --db file:dev.sqlite --dialect sqlite --slug init --apply
+     A new database later (a fresh clone, CI, tests) replays the committed migrations:
+       meta migrate apply-pending --db file:other.sqlite
 `;
 
 export interface InitOptions {
 
@@ -895,6 +895,14 @@ export async function migrateCommand(
       if (exitCode === 0 && emitted) {
         if (config.slug === undefined) {
           log.error(`migrate: --slug <name> required when there are changes (e.g., --slug add-user-shipping)`);
+          // The common way to land here is a NEW database (a fresh clone, CI, another
+          // environment) whose migrations are already committed: the diff against an empty
+          // database is every table, so it asks to author a new migration. That database
+          // needs the committed chain replayed, not a new migration.
+          log.error(
+            `  New database, migrations already committed? Apply them instead: ` +
+            `meta migrate apply-pending --db <url>`,
+          );
           await kysely.close();
           return 2;
         }
 
@@ -1039,7 +1039,8 @@ export async function verifyCommand(
         const text = provider.resolve(ref);
         if (text === undefined) {
           log.error(
-            `[${tmpl.name}] (${label}) ${ERR_PARTIAL_UNRESOLVED}: ref "${ref}" did not resolve under ${promptsDir}`,
+            `[${tmpl.name}] (${label}) ${ERR_PARTIAL_UNRESOLVED}: ref "${ref}" did not resolve under ${promptsDir}` +
+              ` — create ${join(promptsDir, `${ref}.mustache`)} (or .txt), or point --prompts at the directory that holds it`,
           );
           errorCount++;
           anyErrorHere = true;
 
@@ -84,6 +84,8 @@ export interface ResolvedGenConfig {
  *  would generate DB code is required to set them explicitly (see `runGen`'s guard). */
 export const DEFAULT_DIALECT: Dialect = "sqlite";
 export const DEFAULT_DB_IMPORT = "./db";
+/** Import-specifier suffix when the config names none: `./x.js`, right for Node ESM + tsc. */
+export const DEFAULT_EXT_STYLE: ExtStyle = "js";
 
 /**
  * The user-facing codegen config. `dbImport` / `dialect` are OPTIONAL here (unlike the
@@ -93,9 +95,13 @@ export const DEFAULT_DB_IMPORT = "./db";
  * fills inert defaults when they are absent AND the model emits no DB artifacts, and
  * throws a clear error when they are absent but the model DOES emit DB code (#194).
  */
-export interface MetaobjectsGenConfig extends Omit<ResolvedGenConfig, "dbImport" | "dialect"> {
+export interface MetaobjectsGenConfig extends Omit<ResolvedGenConfig, "dbImport" | "dialect" | "extStyle"> {
   dbImport?: string;
   dialect?: Dialect;
+  /** Import-specifier suffix in generated code. Defaults to `"js"` (`./x.js`), which is
+   *  right for Node ESM + tsc. Optional because `meta init` scaffolds a config without it,
+   *  and that config must pass the scaffolded `tsconfig.codegen.json`. */
+  extStyle?: ExtStyle;
   /**
    * Generators to run. Each entry is either a typed generator factory result
    * (`entityFile()`) or a stable-name string (`"entity"`) resolved via the
@@ -205,10 +211,11 @@ export interface MetaobjectsGenConfig extends Omit<ResolvedGenConfig, "dbImport"
  *  TargetConfig to the fully-resolved ResolvedTarget (incompatible under
  *  exactOptionalPropertyTypes otherwise). */
 export interface NormalizedMetaobjectsGenConfig
-  extends Omit<MetaobjectsGenConfig, "targets" | "generators" | "dbImport" | "dialect"> {
+  extends Omit<MetaobjectsGenConfig, "targets" | "generators" | "dbImport" | "dialect" | "extStyle"> {
   /** Resolved to a concrete value (the user's, else the inert default). */
   dbImport: string;
   dialect: Dialect;
+  extStyle: ExtStyle;
   /** Fully resolved — every string spec has been mapped to its factory result. */
   generators: Generator[];
   columnNamingStrategy: ColumnNamingStrategy;
@@ -393,6 +400,7 @@ export function normalizeConfig(config: MetaobjectsGenConfig): NormalizedMetaobj
     ...config,
     dbImport: config.dbImport ?? DEFAULT_DB_IMPORT,
     dialect,
+    extStyle: config.extStyle ?? DEFAULT_EXT_STYLE,
     generators: resolveGenerators(config.generators),
     columnNamingStrategy: config.columnNamingStrategy ?? DEFAULT_COLUMN_NAMING_STRATEGY,
     pluralizeCollections: config.pluralizeCollections ?? true,
 
@@ -263,6 +263,10 @@ export function shouldNoteNamesArtifactAbsent(
   return versionBefore(was, since);
 }
 
+/** What a generator reads as `dbImport` when the config declares none. Emitting it means the
+ *  generator needed a db module path; the runner then fails naming that generator. */
+const DB_IMPORT_UNSET = "__METAOBJECTS_DB_IMPORT_UNSET__";
+
 export async function runGen(opts: RunGenOpts): Promise<RunGenResult> {
   const warnings: string[] = [];
   const strategy = opts.mergeStrategy ?? "overwrite";
@@ -725,23 +729,17 @@ export async function runGen(opts: RunGenOpts): Promise<RunGenResult> {
       warn: (msg) => warnings.push(`[${generator.name}] ${msg}`),
     };
 
-    // The point of USE for an undeclared dbImport (see the guard above). Reading
-    // it is what proves this generator emits a db-singleton import, so reading is
-    // what asks for it; a generator that never touches it never demands it. The
-    // throw travels through the `[${generator.name}]` wrapper below, so the message
-    // names the generator that wants the path. Both surfaces are covered because a
-    // generator may read either.
-    if (dbImportUndeclaredFor(selfTarget.name)) {
-      const demand = (): never => {
-        throw new Error(
-          `codegen config is missing dbImport — this generator emits ` +
-            `\`import { db } from …\` and needs the module to import it from. Set dbImport in ` +
-            `metaobjects.config.ts (or on this generator's target). A project whose generated ` +
-            `queries take \`db\` as a parameter never needs it.`,
-        );
-      };
-      Object.defineProperty(renderContext, "dbImport", { get: demand, configurable: true });
-      Object.defineProperty(ctx.config, "dbImport", { get: demand, configurable: true });
+    // The point of USE for an undeclared dbImport (see the guard above). The value a
+    // generator reads is a MARKER, and the demand fires only if the marker reaches the
+    // OUTPUT — that is what proves this generator emits a db-singleton import. It used to
+    // be a throwing getter, which fired on any read: the reference generators copy the
+    // render context with an object spread, and a spread reads every property, so
+    // `entityFile()` demanded a dbImport it never emits. A marker survives the spread
+    // (and any path arithmetic, being a bare specifier) and is checked after generate.
+    const dbImportUndeclared = dbImportUndeclaredFor(selfTarget.name);
+    if (dbImportUndeclared) {
+      Object.defineProperty(renderContext, "dbImport", { value: DB_IMPORT_UNSET, configurable: true, enumerable: true, writable: true });
+      Object.defineProperty(ctx.config, "dbImport", { value: DB_IMPORT_UNSET, configurable: true, enumerable: true, writable: true });
     }
 
     let files: EmittedFile[];
@@ -758,6 +756,14 @@ export async function runGen(opts: RunGenOpts): Promise<RunGenResult> {
       // not five. Emitting nothing is often CORRECT — a form generator on a model
       // with no forms — so this reports, it never fails.
       if (files.length === 0) emptyGenerators.add(generator.name);
+      if (dbImportUndeclared && files.some((f) => f.content.includes(DB_IMPORT_UNSET) || f.path.includes(DB_IMPORT_UNSET))) {
+        throw new Error(
+          `codegen config is missing dbImport — this generator emits ` +
+            `\`import { db } from …\` and needs the module to import it from. Set dbImport in ` +
+            `metaobjects.config.ts (or on this generator's target). A project whose generated ` +
+            `queries take \`db\` as a parameter never needs it.`,
+        );
+      }
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       // `cause` preserves the original throw. Without it a `runGen` caller sees a
 
@@ -1,5 +1,5 @@
 import { describe, test, expect, expectTypeOf } from "bun:test";
-import { defineConfig, normalizeConfig, resolveTargets, DEFAULT_TARGET_NAME, type MetaobjectsGenConfig, type ResolvedGenConfig, type Dialect } from "../src/metaobjects-config.js";
+import { defineConfig, normalizeConfig, resolveTargets, DEFAULT_TARGET_NAME, type MetaobjectsGenConfig, type ResolvedGenConfig, type Dialect, type ExtStyle } from "../src/metaobjects-config.js";
 import type { Generator } from "../src/generator.js";
 
 describe("resolveTargets", () => {
@@ -69,8 +69,11 @@ describe("defineConfig", () => {
 
   test("type-level: MetaobjectsGenConfig embeds ResolvedGenConfig's non-DB fields exactly (#194 — dbImport/dialect are OPTIONAL here, filled by the runner)", () => {
     // Everything except dbImport/dialect matches ResolvedGenConfig field-for-field.
-    expectTypeOf<Pick<MetaobjectsGenConfig, "outDir" | "extStyle" | "outputLayout" | "includeHonoRoutes" | "includeNames" | "includeUiTier" | "providedEnumModule">>()
-      .toEqualTypeOf<Omit<ResolvedGenConfig, "dbImport" | "dialect">>();
+    expectTypeOf<Pick<MetaobjectsGenConfig, "outDir" | "outputLayout" | "includeHonoRoutes" | "includeNames" | "includeUiTier" | "providedEnumModule">>()
+      .toEqualTypeOf<Omit<ResolvedGenConfig, "dbImport" | "dialect" | "extStyle">>();
+    // extStyle is OPTIONAL too: the config `meta init` scaffolds omits it and must still
+    // typecheck; the runner fills DEFAULT_EXT_STYLE.
+    expectTypeOf<MetaobjectsGenConfig["extStyle"]>().toEqualTypeOf<ExtStyle | undefined>();
     // dbImport/dialect are OPTIONAL on the user config (a value-object-only project omits
     // them); ResolvedGenConfig (what generators consume) keeps them required.
     expectTypeOf<MetaobjectsGenConfig["dbImport"]>().toEqualTypeOf<string | undefined>();
 
@@ -18,6 +18,7 @@ import { MetaDataLoader, InMemoryStringSource } from "@metaobjectsdev/metadata";
 import { runGen } from "../src/runner.js";
 import { entityFile } from "../src/generators/entity-file.js";
 import { routesFile } from "../src/generators/routes-file.js";
+import { entityFile as referenceEntityFile } from "../src/reference/entity.js";
 import type { MetaobjectsGenConfig } from "../src/metaobjects-config.js";
 
 let tmp: string;
@@ -105,6 +106,20 @@ describe("#194 item 3 — dbImport/dialect optional for value-object-only and so
     expect(result.files.length).toBeGreaterThan(0);
   });
 
+  test("the REFERENCE entity generator (what `meta eject entity` copies) does not demand dbImport", async () => {
+    // It copies the render context with an object spread, which reads every property.
+    // When the demand was a throwing getter, that read alone convicted a generator whose
+    // output never imports `db`.
+    const root = await load(ENTITY);
+    const cfg = {
+      ...configNoDb(),
+      dialect: "sqlite" as const,
+      generators: [referenceEntityFile()],
+    } as MetaobjectsGenConfig;
+    const result = await runGen({ config: cfg, metadata: root, projectRoot: tmp });
+    expect(result.files.length).toBeGreaterThan(0);
+  });
+
   test("a generator that DOES emit `import { db }` still demands dbImport, and names itself", async () => {
     const root = await load(ENTITY);
     const cfg = {