@@ -12,6 +12,11 @@ import { parseInitArgs } from "../lib/args.js";
 import { log } from "../lib/log.js";
 import { cliVersion } from "../lib/version.js";
 import { findWranglerConfig, parseWranglerConfig } from "@metaobjectsdev/migrate-ts";
+import { readReferenceTemplate, REFERENCE_GENERATOR_NAMES } from "@metaobjectsdev/codegen-ts";
+
+// ADR-0034 scaffold-and-own — `meta init` copies the codegen reference templates into
+// the consumer's repo so they OWN them; metaobjects.config.ts imports them locally.
+const OWNED_GENERATORS_DIR = "codegen/generators";
 
 const META_COMMON_JSON = JSON.stringify(
   {
@@ -46,13 +51,14 @@ const METAOBJECTS_GITIGNORE_BODY = `.gen-state/
 
 function buildMetaobjectsConfigBody(dialect: "sqlite" | "postgres" | "d1" = "sqlite"): string {
   return `import { defineConfig } from "@metaobjectsdev/cli";
-import {
-  entityFile,
-  queriesFile,
-  routesFile,
-  // formFile,        // opt-in: emit React form components
-  barrel,
-} from "@metaobjectsdev/codegen-ts/generators";
+// Owned codegen generators (ADR-0034 scaffold-and-own). \`meta init\` copied these
+// reference templates into ./codegen/generators/ — they are YOURS to edit, and
+// \`meta gen\` runs from these local copies, not from the package. Read each file's
+// header doc-block for what it emits and how to customize it.
+import { entityFile } from "./codegen/generators/entity";
+import { queriesFile } from "./codegen/generators/queries";
+import { routesFile } from "./codegen/generators/routes";
+import { barrel } from "./codegen/generators/barrel";
 
 export default defineConfig({
   outDir:    "src/generated",
@@ -77,6 +83,7 @@ export default defineConfig({
 
 const NEXT_STEPS = `
 Initialized metaobjects/ + .metaobjects/ + metaobjects.config.ts
+Codegen generators copied to codegen/generators/ — they're YOURS to edit (ADR-0034 scaffold-and-own).
 
 Next steps (when later sub-projects ship):
   meta ingest        # propose entities from your existing TS code
@@ -212,6 +219,27 @@ async function wireRootMemory(cwd: string, result: InitResult): Promise<void> {
   }
 }
 
+/**
+ * ADR-0034 — copy the codegen reference templates into the consumer's repo at
+ * `codegen/generators/<name>.ts` so they own them. Each file is written only if absent,
+ * so a re-run with --force never clobbers a hand-edited generator. The scaffolded
+ * metaobjects.config.ts imports these local copies (not the package `/generators` export).
+ */
+async function writeOwnedGenerators(opts: InitOptions, result: InitResult): Promise<void> {
+  const dir = join(opts.cwd, OWNED_GENERATORS_DIR);
+  await mkdir(dir, { recursive: true });
+  for (const name of REFERENCE_GENERATOR_NAMES) {
+    const rel = `${OWNED_GENERATORS_DIR}/${name}.ts`;
+    const abs = join(dir, `${name}.ts`);
+    if (await fileExists(abs)) {
+      result.preserved.push(rel);
+      continue;
+    }
+    await writeFile(abs, readReferenceTemplate(name), "utf8");
+    result.created.push(rel);
+  }
+}
+
 export async function init(opts: InitOptions): Promise<InitResult> {
   const result: InitResult = { created: [], preserved: [], warnings: [] };
   const agentDir = join(opts.cwd, DEFAULT_METAOBJECTS_DIR);
@@ -254,6 +282,7 @@ export async function init(opts: InitOptions): Promise<InitResult> {
       `.metaobjects/${PACKAGE_MANIFEST_FILE}`,
     );
     result.created.push(".metaobjects/AGENTS.md", ".metaobjects/CLAUDE.md", ".claude/skills/metaobjects-*", AGENT_CONTEXT_MANIFEST_PATH);
+    for (const name of REFERENCE_GENERATOR_NAMES) result.created.push(`${OWNED_GENERATORS_DIR}/${name}.ts`);
     result.created.push("metaobjects.config.ts");
     return result;
   }
@@ -334,6 +363,10 @@ export async function init(opts: InitOptions): Promise<InitResult> {
 
   await writeAgentContext(opts, result);
 
+  // ADR-0034 — scaffold the OWNED codegen generators that metaobjects.config.ts imports
+  // locally. Done before the config so the import targets exist on first `meta gen`.
+  await writeOwnedGenerators(opts, result);
+
   // Scaffold metaobjects.config.ts at the project root. Never overwrite if it exists.
   const forgeConfigPath = join(opts.cwd, "metaobjects.config.ts");
   if (!(await fileExists(forgeConfigPath))) {
 
@@ -76,7 +76,10 @@ describe("metaobjects.config.ts wiring still scaffolded", () => {
     await init({ cwd });
     const configTs = readFileSync(join(cwd, "metaobjects.config.ts"), "utf8");
     expect(configTs).toContain("defineConfig");
-    expect(configTs).toContain("@metaobjectsdev/codegen-ts/generators");
+    // ADR-0034 — the scaffolded config imports the OWNED local generators, never the
+    // deprecated package `/generators` export.
+    expect(configTs).toContain('from "./codegen/generators/entity"');
+    expect(configTs).not.toContain("@metaobjectsdev/codegen-ts/generators");
   });
 });
 
 
@@ -62,3 +62,48 @@ describe("meta init scaffolds metaobjects.config.ts", () => {
     expect(existsSync(join(tmp, "forge.config.ts"))).toBe(false);
   });
 });
+
+// ADR-0034 scaffold-and-own — `meta init` copies the codegen reference templates into
+// the consumer repo (codegen/generators/*.ts), and the scaffolded config imports those
+// OWNED local copies instead of the deprecated package `/generators` export.
+describe("meta init scaffolds OWNED codegen generators (ADR-0034)", () => {
+  const GENERATORS = ["entity", "queries", "routes", "barrel"] as const;
+
+  test("writes codegen/generators/{entity,queries,routes,barrel}.ts", async () => {
+    const result = await init({ cwd: tmp, quiet: true });
+    for (const name of GENERATORS) {
+      const rel = `codegen/generators/${name}.ts`;
+      expect(existsSync(join(tmp, rel))).toBe(true);
+      expect(result.created).toContain(rel);
+    }
+  });
+
+  test("owned generators are the copyable reference templates (REFERENCE TEMPLATE header)", async () => {
+    await init({ cwd: tmp, quiet: true });
+    const entity = readFileSync(join(tmp, "codegen/generators/entity.ts"), "utf-8");
+    expect(entity).toContain("REFERENCE TEMPLATE");
+    // They import the stable engine, never the deprecated `/generators` export.
+    expect(entity).toContain('from "@metaobjectsdev/codegen-ts"');
+    expect(entity).not.toContain("@metaobjectsdev/codegen-ts/generators");
+  });
+
+  test("the scaffolded config imports each owned generator locally", async () => {
+    await init({ cwd: tmp, quiet: true });
+    const body = readFileSync(join(tmp, "metaobjects.config.ts"), "utf-8");
+    expect(body).toContain('import { entityFile } from "./codegen/generators/entity"');
+    expect(body).toContain('import { queriesFile } from "./codegen/generators/queries"');
+    expect(body).toContain('import { routesFile } from "./codegen/generators/routes"');
+    expect(body).toContain('import { barrel } from "./codegen/generators/barrel"');
+    expect(body).not.toContain("@metaobjectsdev/codegen-ts/generators");
+  });
+
+  test("re-init with --force preserves a hand-edited owned generator", async () => {
+    await init({ cwd: tmp, quiet: true });
+    const entityPath = join(tmp, "codegen/generators/entity.ts");
+    const edited = readFileSync(entityPath, "utf-8") + "\n// HAND-EDIT-SENTINEL\n";
+    writeFileSync(entityPath, edited);
+    const result = await init({ cwd: tmp, quiet: true, force: true });
+    expect(readFileSync(entityPath, "utf-8")).toContain("HAND-EDIT-SENTINEL");
+    expect(result.preserved).toContain("codegen/generators/entity.ts");
+  });
+});
@@ -1,8 +1,19 @@
+// ADR-0034 scaffold-and-own — these built-in generator factories remain the engine's
+// internal composers, but importing them from `@metaobjectsdev/codegen-ts/generators`
+// into a consumer's `metaobjects.config.ts` is DEPRECATED. The recommended path is to
+// own copyable reference templates in your repo (`meta init` scaffolds them into
+// `codegen/generators/*.ts`) and import those locally. This package export will be
+// removed in a future major. See spec/decisions/ADR-0034-codegen-scaffold-and-own.md.
+
+/** @deprecated ADR-0034 — own a copy instead: `import { entityFile } from "./codegen/generators/entity"` (scaffolded by `meta init`). */
 export { entityFile, type EntityFileOpts } from "./entity-file.js";
+/** @deprecated ADR-0034 — own a copy instead: `import { queriesFile } from "./codegen/generators/queries"` (scaffolded by `meta init`). */
 export { queriesFile, type QueriesFileOpts } from "./queries-file.js";
 export { callableFile, type CallableFileOpts } from "./callable-file.js";
+/** @deprecated ADR-0034 — own a copy instead: `import { routesFile } from "./codegen/generators/routes"` (scaffolded by `meta init`). */
 export { routesFile, type RoutesFileOpts } from "./routes-file.js";
 export { routesFileHono, type RoutesFileHonoOpts } from "./routes-file-hono.js";
+/** @deprecated ADR-0034 — own a copy instead: `import { barrel } from "./codegen/generators/barrel"` (scaffolded by `meta init`). */
 export { barrel, type BarrelOpts } from "./barrel.js";
 /** @deprecated ADR-0021 D1 — neutral artifact owned by `meta docs` (ADR-0020); not part of the recommended `meta gen` suite. */
 export { mermaidErDiagram, type MermaidErOptions } from "./mermaid-er.js";
 
@@ -76,6 +76,12 @@ export { isTphSubtype, tphDiscriminatorPin } from "./templates/zod-validators.js
 export { renderTphDiscriminatorUnion } from "./templates/tph-discriminator.js";
 export { hasWritableRdbSource } from "./source-detect.js";
 export { renderSharedEnumsFile, SHARED_ENUMS_BASENAME } from "./templates/enums-file.js";
+
+// ADR-0034 scaffold-and-own — reader for the copyable reference generators in
+// `src/reference/*.ts`. `meta init` uses this to copy them into the consumer's repo.
+export { resolveReferenceRoot, readReferenceTemplate, REFERENCE_GENERATOR_NAMES } from "./reference-templates.js";
+export type { ReferenceGeneratorName } from "./reference-templates.js";
+
 export {
   renderFindByIdFn,
   renderListFn,
 
@@ -0,0 +1,49 @@
+// ADR-0034 scaffold-and-own — locate + read the copyable reference generators that
+// live (as raw source assets) in `src/reference/*.ts`. `meta init` reads them through
+// here and writes them into the consumer's repo (e.g. `codegen/generators/*.ts`), which
+// the consumer then OWNS. The templates import only `@metaobjectsdev/codegen-ts` (the
+// stable engine), so a copied file works verbatim with no rewriting.
+//
+// The reference files are excluded from the tsc build (they are scaffold assets, not
+// package source — see tsconfig.json). They ship to npm via the package `files: ["src"]`
+// entry, so they are present at `<pkg>/src/reference/*.ts` in a published install.
+
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** Basenames (no extension) of the copyable reference generators shipped in `src/reference/`. */
+export const REFERENCE_GENERATOR_NAMES = ["entity", "queries", "routes", "barrel"] as const;
+export type ReferenceGeneratorName = (typeof REFERENCE_GENERATOR_NAMES)[number];
+
+/** A directory is the reference root iff it holds the entity reference template. */
+function isReferenceRoot(dir: string): boolean {
+  return existsSync(join(dir, "entity.ts"));
+}
+
+/**
+ * Resolve the `src/reference/` directory holding the copyable reference generators.
+ * Works in dev (this module runs from `src/`, templates at `./reference/`) and in a
+ * published install (this module runs from `dist/`, templates at `../src/reference/`,
+ * since `src/` ships alongside `dist/`). Walks up checking both layouts at each level.
+ */
+export function resolveReferenceRoot(): string {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 8; i++) {
+    for (const candidate of [join(dir, "reference"), join(dir, "src", "reference")]) {
+      if (isReferenceRoot(candidate)) return candidate;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error(
+    "codegen-ts reference templates not found — looked for `reference/` and `src/reference/` " +
+      "walking up from the codegen-ts module.",
+  );
+}
+
+/** Read the raw source of one reference generator (e.g. `"entity"` → the text of `entity.ts`). */
+export function readReferenceTemplate(name: ReferenceGeneratorName): string {
+  return readFileSync(join(resolveReferenceRoot(), `${name}.ts`), "utf8");
+}
@@ -0,0 +1,33 @@
+// ADR-0034 — the reader that `meta init` uses to copy the reference generators into a
+// consumer's repo. It must locate src/reference/ and return the raw template source.
+import { describe, test, expect } from "bun:test";
+import {
+  resolveReferenceRoot,
+  readReferenceTemplate,
+  REFERENCE_GENERATOR_NAMES,
+} from "../src/index.js";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+describe("reference-templates reader", () => {
+  test("exposes the four copyable generator names", () => {
+    expect([...REFERENCE_GENERATOR_NAMES]).toEqual(["entity", "queries", "routes", "barrel"]);
+  });
+
+  test("resolveReferenceRoot points at a dir holding the templates", () => {
+    const root = resolveReferenceRoot();
+    for (const name of REFERENCE_GENERATOR_NAMES) {
+      expect(existsSync(join(root, `${name}.ts`))).toBe(true);
+    }
+  });
+
+  test("readReferenceTemplate returns owned-template source (engine import, copy header)", () => {
+    for (const name of REFERENCE_GENERATOR_NAMES) {
+      const src = readReferenceTemplate(name);
+      expect(src).toContain("REFERENCE TEMPLATE");
+      expect(src).toContain('from "@metaobjectsdev/codegen-ts"');
+      // Never the deprecated package `/generators` export.
+      expect(src).not.toContain("@metaobjectsdev/codegen-ts/generators");
+    }
+  });
+});