diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7d06b489a..10089c882 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -125,8 +125,56 @@ generator catalog and the Atlas evaluation are 1.2 work.
   pages `meta docs` writes) and `agent-docs` (the pages `meta docs --agent` writes), both
   neutral and both still run by `meta docs`; a `generators` entry naming either string is
   refused the way `"docs"` is. Java: `plantuml`, `html-docs`, `ai-docs`, `json-schema` and the
-  deprecated `mustache`, each by the class name a pom already uses. None of the seven ships
-  eject source yet; `mustache` will not.
+  deprecated `mustache`, each by the class name a pom already uses. `mustache` will not ship
+  eject source. The four Java generators that can ship it do: see **Java and Kotlin** below.
+
+- **Java and Kotlin: eject hands over the emitters a generator writes through, and
+  `api-docs`, `plantuml`, `html-docs`, `ai-docs` and `json-schema` are ejectable.** An ejected
+  Java or Kotlin generator used to be one file over packaged emitters, so a defect in the enum,
+  record-builder, extraction-mirror or prompt-format writers still waited for a release. Eject
+  now copies those emitters with the generator, into its package, and points the imports the
+  copies have of one another at the copies. Java `dto` and `value-object` take
+  `Fr019SharedEnum` and `SpringRecordBuilder`; Java `output-parser` takes `Fr019SharedEnum`;
+  Java `output-prompt` takes `OutputFormatSpecEmitter`; Kotlin `entity` takes
+  `KotlinEnumEmitter`; Kotlin `output-parser` takes `KotlinExtractSchemaEmitter`; Kotlin
+  `output-prompt` takes `KotlinOutputFormatSpecEmitter` and `KotlinExtractSchemaEmitter`. A
+  class two generators share is written once and never overwritten. The naming and type-mapping
+  tables, the model walks and the generator bases stay in the package as the engine. Kotlin
+  `Fr019SharedEnum` is engine: it writes nothing, and the type mapper takes its
+  `ProvidedEnumConfig` as an argument, so its `providedInDeclarationPackage` and
+  `DECLARATION_PACKAGE` members are now public. Packaged output is unchanged. A copy you ejected earlier keeps compiling with the packaged
+  emitters; own them with the recipe in
+  [own-your-codegen](docs/features/own-your-codegen.md#ejecting-a-generator-hands-over-the-emitters-it-writes-through-java-and-kotlin).
+  - **`api-docs` is a generator, and ejectable, in Java and Kotlin.** The api reference is
+    `JavaApiDocsGenerator` / `KotlinApiDocsGenerator`, a `<generator>` entry like any other:
+    `metaobjects:generate` runs it and `metaobjects:verify` checks it, with `outputDir`,
+    `apiSubDir`, `layout`, `projectName` and `modelBaseUrl` in its `<args>`. It replaces the
+    `metaobjects:docs` goal (see **Removed**). Eject
+    copies the generator, the page model, the builder, the renderer and the path math into a
+    subpackage per port, `<package>.apidocs.java` or `<package>.apidocs.kotlin`: the two ports
+    name those classes alike, so one `codegen/` module can hold both without a class declared
+    twice. Eject prints the class name to list. Eject writes `codegen/pom.xml` for the ports
+    the module holds at that moment and never edits it afterwards. One call that ejects for
+    both ports now gets a pom that builds both source trees; it used to leave `src/main/java`
+    out. When a later call adds a port, the pom does not declare what that port needs (the
+    `metaobjects-codegen-*` dependency, `kotlin-maven-plugin`, or `src/main/java` as a source
+    root after a Kotlin-first eject), and eject now warns and prints what to add. For Java the page templates come too, into
+    `codegen/src/main/resources/<package path>/apidocs/java/templates/`, with the copied
+    template provider pointed there. What the Java reference documents is still what the
+    packaged generators emit for (`GeneratorApplicability.packaged()`): an owned `routes` whose
+    `appliesTo` you changed is documented as the packaged one behaves, unless you change the
+    line of your `JavaApiDocsGenerator` copy that builds it. The pages are the ones 8.0's
+    docs goal wrote, given the same options.
+  - **The Java `plantuml`, `html-docs`, `ai-docs` and `json-schema` generators ship eject
+    source**, each with the writer that emits its file. `SingleHtmlDirectGeneratorBase` now
+    drives the new `HtmlDirectWriter`, as the JSON base drives `JsonDirectWriter`, so a copied
+    HTML generator pairs with the copy of its writer. A subclass that overrode
+    `writeHtml(MetaDataHtmlDocumentationWriter)` keeps being called, through a deprecated bridge the
+    base still calls; one that returns the stock writer from `getWriter` still compiles. A subclass
+    compiled against 1.0.x needs a recompile, because the method's return type changed. The attributes the JSON Schema and AI documentation generators
+    add to the metamodel moved to `CodeGenMetaDataProvider`, where the loader registers them,
+    so a copy owns emit code only; the old static methods and constants on the two generators
+    stay as deprecated forwarders.
 
 - **The Java `entity` and `extractor` generators can be ejected.**
   `mvn metaobjects:eject -Dnames=entity,extractor -Dport=java` copies each generator, with
@@ -139,25 +187,21 @@ generator catalog and the Atlas evaluation are 1.2 work.
   Amendment 6.
   - **The owned `entity` includes the class body.** Eject copies seven files into one
     package: `JavaObjectCodeGenerator`, the two bases it extends (`JavaCodeGenerator`,
-    `BaseObjectCodeGenerator`), and the four writers that emit each class
+    `BaseObjectCodeGenerator`) and the four writers that emit each class
     (`BaseObjectCodeWriter`, `JavaCodeWriter`, `PojoAwareCodeWriter`,
     `ValueObjectCodeWriter`). The copies use one another, never the packaged classes: where
     one imports another, eject rewrites that import along with the package line. You change
     a field, a constructor or an accessor by editing the writer, with nothing to subclass.
     `-Dlist` gives `entity` one verdict over all seven files. Details:
     [own-your-codegen](docs/features/own-your-codegen.md#java-entity-and-extractor).
-  - **`extractor` is a generator of its own (Java).** `ExtractorCodeGenerator` can be named
+  - **`extractor` is a generator of its own (Java).** `ExtractorCodeGenerator` is named
     in `<generators>`, with the same `outputDir`, `pkgPrefix`, `pkgSuffix`, `namePrefix`,
-    `nameSuffix` and `<filters>` as your `entity` generator. When it is, the plugin sets
-    `emitExtractors=false` on `entity`, so each `<Name>Extractor` has one emitter; an
-    `emitExtractors=true` in the pom does not override that. Outside Maven, set the arg
-    yourself. Ejecting it also copies `JavaCodeWriter` and `BaseObjectCodeWriter`, where it
-    reads class names from. In the same package as an owned `entity`, the two share that
-    one copy.
-  - **A pom that wires only `entity` still writes the extractors.** Its class files change
-    once, in the header comment only: see **Changed** below.
-  - New public API: in `metaobjects-codegen-base`, the `EmitsObjectExtractors` marker, whose
-    `ARG_EMIT_EXTRACTORS` names the `emitExtractors` arg; in `metaobjects-codegen-spring`,
+    `nameSuffix` and `<filters>` as your `entity` generator, and it is the one generator that
+    writes `<Name>Extractor` classes (see **Removed**). Ejecting it also copies `JavaCodeWriter` and `BaseObjectCodeWriter`, where it
+    reads class names from. In the same package as an owned `entity`, the two share those
+    writers.
+  - **`entity`'s class files change once**, in the header comment only: see **Changed** below.
+  - New public API: in `metaobjects-codegen-spring`,
     `GeneratorRegistry.GeneratorInfo.ejectWith()`, the classes eject copies with a
     generator.
 
@@ -947,6 +991,29 @@ until you regenerate.
 
 ### Removed
 
+- **Java and Kotlin: the `metaobjects:docs` goal.** Documentation is generated the way code
+  is: the api reference is a `JavaApiDocsGenerator` or `KotlinApiDocsGenerator` `<generator>`
+  entry in the list `metaobjects:generate` runs, with its options in `<args>` (see
+  **Added**), and nothing is written that `<generators>` does not declare. A pom that still
+  binds the goal fails with a line naming `mvn metaobjects:generate` and the migration
+  section. `generate` and `verify` refuse a pom that still sets the goal's parameters
+  (`<language>`, `<apiSubDir>`, `<layout>`, `<modelBaseUrl>`) instead of running and writing
+  no documentation. Ruling: ADR-0034 Amendment 9, which makes this the rule in all five ports
+  and numbers the release 1.1.0 (Maven 8.1.0) by the maintainer's explicit decision.
+  - **To upgrade**, replace the `docs` execution with one `<generator>` entry per language;
+    before and after `pom.xml`, and each parameter's new name, are in
+    [docs-are-generators.md, "Java and Kotlin"](docs/features/migrations/docs-are-generators.md#java-and-kotlin).
+    The page header's project label was the module's `artifactId`; set
+    `<projectName>${project.artifactId}</projectName>` to keep the pages byte for byte.
+- **Java: `entity` no longer writes `<Name>Extractor` classes.** Through 8.0,
+  `JavaObjectCodeGenerator` wrote one beside each concrete class when the pom listed no
+  `extractor`: output no `<generator>` entry declared. Only `ExtractorCodeGenerator` writes
+  them now.
+  - **To upgrade**, if your code calls `<Name>Extractor` and your pom lists `entity` without
+    `extractor`: add an `ExtractorCodeGenerator` entry with the `entity` entry's `outputDir`,
+    naming args and `<filters>`
+    ([migration](docs/features/migrations/docs-are-generators.md#java-and-kotlin)).
+
 - **The standalone `mermaid-er` generator (TypeScript).** `mermaidErDiagram()`, its
   `MermaidErOptions` type and the stable name `"mermaid-er"` are gone from
   `@metaobjectsdev/codegen-ts/generators`, the generator catalog and the cross-port
@@ -1109,13 +1176,13 @@ until you regenerate.
 
   - Every Kotlin generator that types an enum now takes `providedEnumNamespace` /
     `providedEnumPackages`: the entity, Exposed table, Spring controller, relations and
-    output-parser generators, and the API pages `mvn metaobjects:docs` writes. Only the entity
+    output-parser generators, and `KotlinApiDocsGenerator`. Only the entity
     generator read them before, so for a `@provided` enum the data class named your class while
     the Exposed table and the controller named a class in the declaration's package that nothing
     generates, and the output did not compile. They now all resolve it through one function. A
     generator configured without the args fails at generate time for a model with a `@provided`
     enum, naming the enum, its package and both args. Set them once in the plugin's `<globals>`
-    and every generator, and the docs goal, reads the same values.
+    and every generator reads the same values.
   - **Upgrading an owned Kotlin generator.** A copy ejected before this release keeps compiling
     unchanged. The helper signatures it calls remain as deprecated forms:
     `KotlinTypeMapper.enumTypeName(field, entity)`, `KotlinEnumEmitter.emitEnumFile` without a
diff --git a/README.md b/README.md
index 6ddbb233a..411ba70bc 100644
--- a/README.md
+++ b/README.md
@@ -134,7 +134,7 @@ first-week wedge plan — and `meta init` picks up from there.
 |---|---|---|---|
 | TypeScript | **npm `1.0.13`** — the `@metaobjectsdev/*` packages | [`docs/ports/typescript.md`](docs/ports/typescript.md) | [`server/typescript/`](server/typescript/) · [`client/web/`](client/web/) |
 | Java | **Maven Central `8.0.13`** (`com.metaobjects:*` — the JVM major is npm major + 7) — loader + OMDB + render + Maven plugin all shipped; full conformance green | [`docs/ports/java.md`](docs/ports/java.md) | [`server/java/`](server/java/) |
-| Kotlin | **Maven Central `8.0.13`** — codegen tier on top of Java: 15 generators (entity, Exposed table, names, relations, repository, output-parser, output-prompt, render-helper, extractor, filter-allowlist, validator, Spring config, storedProc, Spring controller, requirement-tests); 24 / 24 persistence-conformance | [`docs/ports/kotlin.md`](docs/ports/kotlin.md) | [`server/java/codegen-kotlin/`](server/java/codegen-kotlin/) · [`server/java/metadata-ktx/`](server/java/metadata-ktx/) |
+| Kotlin | **Maven Central `8.0.13`** — codegen tier on top of Java: 16 generators (entity, Exposed table, names, relations, repository, output-parser, output-prompt, render-helper, extractor, filter-allowlist, validator, Spring config, storedProc, Spring controller, requirement-tests, api-docs); 24 / 24 persistence-conformance | [`docs/ports/kotlin.md`](docs/ports/kotlin.md) | [`server/java/codegen-kotlin/`](server/java/codegen-kotlin/) · [`server/java/metadata-ktx/`](server/java/metadata-ktx/) |
 | C# | **NuGet `1.0.13`** — loader + conformance + EF Core codegen + render engine + `dotnet meta` CLI all shipped | [`docs/ports/csharp.md`](docs/ports/csharp.md) | [`server/csharp/`](server/csharp/) |
 | Python | **PyPI `1.0.13`** — loader + conformance + render + entity-model codegen + ObjectManager runtime shipped; schema migrations are TS-owned (ADR-0015) | [`docs/ports/python.md`](docs/ports/python.md) | [`server/python/`](server/python/) |
 
diff --git a/agent-context/servers/csharp.meta.json b/agent-context/servers/csharp.meta.json
index d305d78a1..a41c5d26e 100644
--- a/agent-context/servers/csharp.meta.json
+++ b/agent-context/servers/csharp.meta.json
@@ -3,5 +3,7 @@
   "install": "install the MetaObjects .NET tool (dotnet tool install) + add the MetaObjects.Codegen package",
   "codegenCommand": "dotnet meta gen",
   "docsCommand": "dotnet meta docs",
+  "docsCondition": "",
+  "docsMissing": "",
   "apiSubDir": "api/csharp"
 }
diff --git a/agent-context/servers/java.meta.json b/agent-context/servers/java.meta.json
index f2c3273f7..b0fffe246 100644
--- a/agent-context/servers/java.meta.json
+++ b/agent-context/servers/java.meta.json
@@ -2,6 +2,8 @@
   "displayName": "Java",
   "install": "add com.metaobjects:metaobjects-metadata + metaobjects-codegen-spring + metaobjects-maven-plugin to your pom.xml",
   "codegenCommand": "mvn metaobjects:generate",
-  "docsCommand": "mvn metaobjects:docs",
+  "docsCommand": "mvn metaobjects:generate",
+  "docsCondition": " (when the project's generator list declares the api-docs generator)",
+  "docsMissing": "Declare `com.metaobjects.generator.apidocs.JavaApiDocsGenerator` as a `<generator>` entry in the pom's `<generators>` if it is missing",
   "apiSubDir": "api/java"
 }
diff --git a/agent-context/servers/kotlin.meta.json b/agent-context/servers/kotlin.meta.json
index e9dd7d930..72beb7ef8 100644
--- a/agent-context/servers/kotlin.meta.json
+++ b/agent-context/servers/kotlin.meta.json
@@ -2,6 +2,8 @@
   "displayName": "Kotlin",
   "install": "add com.metaobjects:metaobjects-codegen-kotlin + metaobjects-metadata-ktx + metaobjects-maven-plugin to your pom.xml",
   "codegenCommand": "mvn metaobjects:generate",
-  "docsCommand": "mvn metaobjects:docs",
+  "docsCommand": "mvn metaobjects:generate",
+  "docsCondition": " (when the project's generator list declares the api-docs generator)",
+  "docsMissing": "Declare `com.metaobjects.generator.kotlin.apidocs.KotlinApiDocsGenerator` as a `<generator>` entry in the pom's `<generators>` if it is missing",
   "apiSubDir": "api/kotlin"
 }
diff --git a/agent-context/servers/python.meta.json b/agent-context/servers/python.meta.json
index dcfea618d..bfb1a8e27 100644
--- a/agent-context/servers/python.meta.json
+++ b/agent-context/servers/python.meta.json
@@ -3,5 +3,7 @@
   "install": "pip install metaobjects",
   "codegenCommand": "metaobjects gen",
   "docsCommand": "metaobjects docs",
+  "docsCondition": "",
+  "docsMissing": "",
   "apiSubDir": "api/python"
 }
diff --git a/agent-context/servers/typescript.meta.json b/agent-context/servers/typescript.meta.json
index 38f5a718b..255274675 100644
--- a/agent-context/servers/typescript.meta.json
+++ b/agent-context/servers/typescript.meta.json
@@ -3,5 +3,7 @@
   "install": "npm install -D @metaobjectsdev/cli @metaobjectsdev/codegen-ts",
   "codegenCommand": "npx meta gen",
   "docsCommand": "npx meta docs",
+  "docsCondition": "",
+  "docsMissing": "",
   "apiSubDir": "api"
 }
diff --git a/agent-context/skills/metaobjects-codegen/references/java.md b/agent-context/skills/metaobjects-codegen/references/java.md
index d8e1855ab..c02465c15 100644
--- a/agent-context/skills/metaobjects-codegen/references/java.md
+++ b/agent-context/skills/metaobjects-codegen/references/java.md
@@ -10,7 +10,7 @@ Maven plugin goal — there is no standalone `meta` binary on the Java side (the
 - Run
 - Write your own generator
 - When a generator's output is wrong — own the generator
-- Docs — `mvn metaobjects:docs`
+- Docs — the `api-docs` generator
 - `codegen-spring` generators
 - Discriminator inheritance (TPH)
 - Serializing generated objects
@@ -138,16 +138,24 @@ repository.
 When a later MetaObjects release changes the reference generator, diff it against your
 copy and take what you want. Nothing in your build changes until you do.
 
-## Docs — `mvn metaobjects:docs`
+## Docs — the `api-docs` generator
 
-A separate `docs` goal (`DocsMojo` — NOT a `<generator>`) emits this project's SDK api
-surface (default `target/docs/api/java`), including `AGENT-API.md` — the exact imports,
-signatures, and payload field shapes for the generated code.
+The SDK api reference is a `<generator>` entry like any other, run by
+`mvn metaobjects:generate`. It writes `AGENT-API.md` — the exact imports, signatures, and
+payload field shapes for the generated code — plus a page per entity, under
+`<outputDir>/api/java`. Nothing writes it unless the pom lists it; there is no docs goal
+(removed in 8.1.0).
 
-```bash
-mvn metaobjects:docs   # → target/docs/api/java (AGENT-API.md + per-entity pages)
+```xml
+<generator>
+  <classname>com.metaobjects.generator.apidocs.JavaApiDocsGenerator</classname>
+  <args><outputDir>${project.build.directory}/docs</outputDir></args>
+</generator>
 ```
 
+Optional `<args>`: `apiSubDir` (default `api/java`), `layout` (`flat` or `package`),
+`projectName`, `modelBaseUrl`. Give it an `outputDir` of generated files only.
+
 **Before calling any generated code, read `api/java/AGENT-API.md`** — it carries the
 concrete imports and signatures so you don't have to guess them.
 
@@ -170,8 +178,8 @@ separate `metaobjects-codegen-base` module instead.)
 | `LlmTraceHelperGenerator` | `<Entity>TraceHelper.java` per concrete entity — the LLM-trace helper |
 | `SpringFilterAllowlistGenerator` | per-entity filter allowlist |
 | `SpringNamesGenerator` | `<Entity>Names.java` — `public abstract class` of `static final String` names that MIRRORS THE METADATA TREE. Every node carries its own `TYPE`/`SUB_TYPE`/`NAME`, so `AuthorNames.NAME` is the OBJECT's name (`"Author"`), **not** a table name, and a physical name sits under the member that says what it is: `SOURCE_<ROLE>_TABLE` / `_VIEW` / `_MATERIALIZED_VIEW` / `_PROC` / `_FUNCTION`, from the metamodel's own `@kind`-to-alias map, with `<ROLE>` being `PRIMARY` or `REPLICA` (a write-through entity has a member for each). Plus a `<FIELD>_FIELD`/`<FIELD>_COLUMN` pair per field and a complete `COLUMNS_BY_FIELD`; an `identity.secondary` or `index.lookup` also carries `IDENTITY_<NAME>_INDEX` / `INDEX_<NAME>_INDEX`, while `identity.primary` deliberately carries no index member (migrate names a PK by a dialect-conditional formula this artifact must not restate). **There is no `READ_ONLY`** — it was a derivation over `@kind`, never metadata, so ask `SOURCE_<ROLE>_KIND`. Emitted for every object with a declared or inherited primary source, PLUS a fragment for any abstract base such an object extends (columns only, no source). A class whose object extends another one **extends** it (`class CopayAuthNames extends AuthNames`) rather than restating its constants — Java inherits static members, so `CopayAuthNames.SOURCE_PRIMARY_TABLE` and `CopayAuthNames.ID_COLUMN` both resolve through the base. **This port generates no SQL** (the repository is an interface you implement), so nothing generated consumes these — they exist for your implementation. |
-| `JavaObjectCodeGenerator` | module `metaobjects-codegen-base` (`com.metaobjects.generator.direct.object.javacode`), a separate module from the Spring generators above. Flavor-selected via the `flavor` generator arg. `flavor=pojoAware` → `class <Name> extends PojoObject` (a concrete `MetaObjectAware` class with a `(MetaObject)` constructor) — its inherited `getMetaData()` back-reference is what breaks a default Jackson/Gson mapper, see "Serializing generated objects" below. `flavor=valueObject` → `class <Name> extends ValueObject` (map-backed; less hostile to a default mapper, but still not the sanctioned serialization path). Either concrete flavor also emits a self-registering `ObjectClassBindingProvider`, and a `<Name>Extractor` per concrete class unless `ExtractorCodeGenerator` is wired too. For a plain default-Jackson-friendly type, use the `codegen-spring` record surface instead — never `pojoAware`. |
-| `ExtractorCodeGenerator` | also in `metaobjects-codegen-base`. One `<Name>Extractor` per concrete object, the same files `JavaObjectCodeGenerator` writes when this is not wired. Wire it as its own `<generator>` only to own it or to give it different args: same `outputDir`, `pkgPrefix` / `pkgSuffix` / `namePrefix` / `nameSuffix` and `<filters>` as the entity generator, which must run a concrete flavor in the same `<generators>` (an extractor for an object the entity generator wrote no class for does not compile). The plugin then stops the entity generator writing them. A pom with more than one entity generator entry needs one `ExtractorCodeGenerator` entry per entity entry, each with that entry's `outputDir`, naming args and `<filters>`: a single extractor generator in the run stops every entity entry writing its extractors. |
+| `JavaObjectCodeGenerator` | module `metaobjects-codegen-base` (`com.metaobjects.generator.direct.object.javacode`), a separate module from the Spring generators above. Flavor-selected via the `flavor` generator arg. `flavor=pojoAware` → `class <Name> extends PojoObject` (a concrete `MetaObjectAware` class with a `(MetaObject)` constructor) — its inherited `getMetaData()` back-reference is what breaks a default Jackson/Gson mapper, see "Serializing generated objects" below. `flavor=valueObject` → `class <Name> extends ValueObject` (map-backed; less hostile to a default mapper, but still not the sanctioned serialization path). Either concrete flavor also emits a self-registering `ObjectClassBindingProvider`; it writes no extractors. For a plain default-Jackson-friendly type, use the `codegen-spring` record surface instead — never `pojoAware`. |
+| `ExtractorCodeGenerator` | also in `metaobjects-codegen-base`. One `<Name>Extractor` per concrete object, and the only generator that writes them: list it or get none. Give it the same `outputDir`, `pkgPrefix` / `pkgSuffix` / `namePrefix` / `nameSuffix` and `<filters>` as the entity generator, which must run a concrete flavor in the same `<generators>` (an extractor for an object the entity generator wrote no class for does not compile). A pom with more than one entity generator entry needs one `ExtractorCodeGenerator` entry per entity entry, each with that entry's `outputDir`, naming args and `<filters>`. |
 
 **Owning one of these two.** `mvn metaobjects:eject -Dnames=entity,extractor -Dport=java`
 copies each generator into the `codegen/` module with the rest of its emit (`-Dport` is
diff --git a/agent-context/skills/metaobjects-codegen/references/kotlin.md b/agent-context/skills/metaobjects-codegen/references/kotlin.md
index 64b67df90..0f470d98a 100644
--- a/agent-context/skills/metaobjects-codegen/references/kotlin.md
+++ b/agent-context/skills/metaobjects-codegen/references/kotlin.md
@@ -136,17 +136,24 @@ repository.
 When a later MetaObjects release changes the reference generator, diff it against your
 copy and take what you want. Nothing in your build changes until you do.
 
-## Docs — `mvn metaobjects:docs -Dmetaobjects.docs.language=kotlin`
+## Docs — the `api-docs` generator
 
-The shared `docs` goal (`DocsMojo`) renders the Kotlin SDK api surface via
-`KotlinApiDocsRenderer` when pointed at the Kotlin language (default `target/docs/api/kotlin`),
-including `AGENT-API.md` — the exact imports, signatures, and payload field shapes for the
-generated code.
+The Kotlin SDK api reference is a `<generator>` entry like any other, run by
+`mvn metaobjects:generate`. It writes `AGENT-API.md` — the exact imports, signatures, and
+payload field shapes for the generated code — plus a page per entity, under
+`<outputDir>/api/kotlin`. Nothing writes it unless the pom lists it; there is no docs goal
+(removed in 8.1.0).
 
-```bash
-mvn metaobjects:docs -Dmetaobjects.docs.language=kotlin   # → target/docs/api/kotlin (AGENT-API.md + per-entity pages)
+```xml
+<generator>
+  <classname>com.metaobjects.generator.kotlin.apidocs.KotlinApiDocsGenerator</classname>
+  <args><outputDir>${project.build.directory}/docs</outputDir></args>
+</generator>
 ```
 
+Optional `<args>`: `apiSubDir` (default `api/kotlin`), `layout` (`flat` or `package`),
+`projectName`, `modelBaseUrl`. Give it an `outputDir` of generated files only.
+
 **Before calling any generated code, read `api/kotlin/AGENT-API.md`.**
 
 ## `codegen-kotlin` generators
diff --git a/agent-context/templates/always-on.md.mustache b/agent-context/templates/always-on.md.mustache
index 69a23e79f..fd09ccbd0 100644
--- a/agent-context/templates/always-on.md.mustache
+++ b/agent-context/templates/always-on.md.mustache
@@ -29,7 +29,7 @@ inferring the answer from generated code, which is the disposable half.
 Not there? Run `meta docs`. It reads the metadata and the config and needs nothing else.
 {{/nodeDocsSurface}}
 {{^nodeDocsSurface}}
-`{{docsCommand}}` writes ONE reference file under this project's docs output directory. It
+`{{docsCommand}}` writes ONE reference file under this project's docs output directory{{docsCondition}}. It
 is generated from THIS project's metadata, so it describes what the project actually is
 rather than what the framework does in general — and reading it first is how you avoid
 inferring the answer from generated code, which is the disposable half.
@@ -37,7 +37,7 @@ inferring the answer from generated code, which is the disposable half.
 - **`{{apiSubDir}}/AGENT-API.md`** — before calling generated code. The types, endpoints and
   filter operators the generators actually emitted.
 
-Not there? Run `{{docsCommand}}`.
+Not there? {{docsMissingAction}} `{{docsCommand}}`.
 
 The other three pages of that reference — `agent/schema.md` (persistence), `agent/ui.md`
 (forms and grids) and `agent/requirements.md` (what is already claimed, and what was
diff --git a/docs/features/cli.md b/docs/features/cli.md
index 806641525..55d5fae12 100644
--- a/docs/features/cli.md
+++ b/docs/features/cli.md
@@ -37,7 +37,7 @@ command surface splits in two:
 | **Canonical format** (`fmt`) | every port | `meta fmt` / `dotnet meta fmt` / `mvn metaobjects:fmt` / `metaobjects fmt` | (#304) ships in **every** port — the canonical serializer already exists in all five, so formatting is local, not Node-only. `--check` lists non-canonical files and exits non-zero without changing anything. Formats each file STANDALONE — own-mode, declared-here layer only (ADR-0039); an `extends` onto another file's base is preserved as-is, never resolved or erred on; a file declaring `overlay: true` anywhere — whether or not a same-file base exists — is reported as skipped rather than merged (merging would drop the overlay marker, a structural change fmt never makes). A YAML file is always skipped — no canonical YAML emitter exists (ADR-0006). Before writing, every port reloads the whole project with the candidate swapped in and refuses the write unless the reloaded model's canonical form is byte-identical to the untouched baseline — fmt never changes meaning. See [Fixture corpus](#meta-fmt--canonical-formatting-304) below and `fixtures/fmt-conformance/README.md` |
 | TS codegen | Node `meta` | `meta gen` | TS projects. **No `--template-spec` flag, deliberately** — `metaobjects.config.ts` already takes generator VALUES, so a declarative template generator is declared there (`templateGenerator()`, or `templateSpecToGenerators(parseTemplateSpec(spec))` to reuse a C#/Python spec file). Keeping it in the config is what lets `meta verify --codegen` regenerate WITH it, since that gate re-runs the config's generator list; see [declarative template scopes](codegen-concepts.md#declarative-template-scopes) |
 | C# codegen | `dotnet meta` | `dotnet meta gen` / `verify --templates` / `verify --codegen` | a .NET tool (`ToolCommandName=dotnet-meta`); invoked `dotnet meta` so it never shadows the Node `meta`; ships the ADR-0021 D2 subverbs (`--db` rejected, exit 2; bare `verify` = `--templates`). `gen` also accepts `--template-spec <json>` (+ `--template-root <dir>`, default `prompts/` when it exists, else `templates/`) — the declarative Mustache template-codegen surface (the cross-port JSON contract shared with Python), **auto-discovered at `<projectRoot>/template-spec.json`** when the flag is absent. Prefer the conventional path: `verify --codegen` takes no `--template-spec`, so discovery is how the drift gate sees your template generators at all; see [declarative template scopes](codegen-concepts.md#declarative-template-scopes) |
-| Java/Kotlin codegen | Maven plugin | `mvn metaobjects:generate` (`metaobjects:generate`) | Kotlin generators run through the same goal — see below. **No `--template-spec` flag, deliberately** — `<generator>` already loads a consumer class from the project classpath, so the declarative surface is `com.metaobjects.generator.template.TemplateScopeGenerator` wired as an ordinary `<generator>` with `<template>` / `<scope>` / `<outputPattern>` / `<templatesDir>` / `<format>` args (covers BOTH Java and Kotlin); see [declarative template scopes](codegen-concepts.md#declarative-template-scopes). The `generate`/`verify`/`docs` goals are declared `threadSafe` and support parallel multi-module reactor builds (`mvn -T`) (#233) |
+| Java/Kotlin codegen | Maven plugin | `mvn metaobjects:generate` (`metaobjects:generate`) | Kotlin generators run through the same goal — see below. **No `--template-spec` flag, deliberately** — `<generator>` already loads a consumer class from the project classpath, so the declarative surface is `com.metaobjects.generator.template.TemplateScopeGenerator` wired as an ordinary `<generator>` with `<template>` / `<scope>` / `<outputPattern>` / `<templatesDir>` / `<format>` args (covers BOTH Java and Kotlin); see [declarative template scopes](codegen-concepts.md#declarative-template-scopes). The `generate` and `verify` goals are declared `threadSafe` and support parallel multi-module reactor builds (`mvn -T`) (#233) |
 | Java/Kotlin verify | Maven plugin | `mvn metaobjects:verify -Dmeta.verify.mode=codegen\|templates` (`metaobjects:verify`) | parameter-driven ADR-0021 D2 modes (one goal covers BOTH Java + Kotlin): `codegen` (default, back-compat — regen + fail on drift vs committed output, generator-neutral) / `templates` (`{{field}}`↔payload drift via the render `Verify` engine). `db` rejected ("schema verify is the migrate engine, ADR-0015") |
 | Python codegen | console-script | `metaobjects gen` / `verify --codegen` / `verify --templates` | `[project.scripts] metaobjects` — **not** `meta` (that's the Node schema CLI); ships the ADR-0021 D2 subverbs (`--db` rejected, exit 2). `gen` also accepts `--template-spec <json>` (+ `--templates <dir>`, default `prompts/` when it exists, else `templates/`) — the declarative Mustache template-codegen surface (the cross-port JSON contract shared with C#), **auto-discovered at `<projectRoot>/template-spec.json`** when the flag is absent (and REFUSED in declarative-config mode, where a spec has no target to write into). Prefer the conventional path: `verify --codegen` takes no `--template-spec`, so discovery is how the drift gate sees your template generators at all; see [declarative template scopes](codegen-concepts.md#declarative-template-scopes) |
 
diff --git a/docs/features/migrations/docs-are-generators.md b/docs/features/migrations/docs-are-generators.md
new file mode 100644
index 000000000..4e4acf3dc
--- /dev/null
+++ b/docs/features/migrations/docs-are-generators.md
@@ -0,0 +1,170 @@
+# Migration: documentation is a generator you declare
+
+**Removed in:** 1.1.0 (Maven 8.1.0) · **Ports affected:** all five
+**Automatic fix:** none. Each section below is written so you, or a coding agent working in
+your repository, can make the change by hand.
+
+## What changed
+
+Through 1.0, documentation had a door of its own: `meta docs`, `dotnet meta docs`,
+`metaobjects docs` and the Maven goal `metaobjects:docs`. Each wrote pages nobody listed,
+from options of its own. In 1.1.0 there is one way to generate, in every port
+(ADR-0034 Amendment 9):
+
+- Every generator, documentation included, is an entry in your project's generator list,
+  with its options in the entry.
+- The gen command (Maven: `metaobjects:generate`) runs that list, and `verify` checks it.
+- Nothing is written that the list does not declare.
+
+The docs commands and the docs goal are removed. Running one prints the line that names
+the gen command and this page. A gen run that still finds 1.0 docs configuration fails
+before writing anything, so a build never passes while silently writing no documentation.
+
+## Java and Kotlin
+
+**What you see.** A pom that binds the `docs` goal fails with:
+
+```
+metaobjects:docs was removed in 8.1.0. `mvn metaobjects:generate` writes documentation now: declare each docs generator as a <generator> entry in the plugin's <generators>. See docs/features/migrations/docs-are-generators.md, section "Java and Kotlin".
+```
+
+A pom that still sets the goal's parameters fails in `generate` and `verify` with a line
+that starts `metaobjects:generate: found 1.0 docs configuration (` and names each element
+it found.
+
+**Before (8.0).** The `docs` goal, with its parameters in the plugin's `<configuration>`:
+
+```xml
+<plugin>
+  <groupId>com.metaobjects</groupId>
+  <artifactId>metaobjects-maven-plugin</artifactId>
+  <configuration>
+    <loader>...</loader>
+    <outputDirectory>${project.build.directory}/docs</outputDirectory>
+    <language>java,kotlin</language>
+    <layout>package</layout>
+    <modelBaseUrl>https://docs.example.com/model</modelBaseUrl>
+    <generators>
+      <generator>
+        <classname>com.metaobjects.generator.spring.SpringDtoGenerator</classname>
+        <args><outputDir>${project.build.directory}/generated-sources/java</outputDir></args>
+      </generator>
+    </generators>
+  </configuration>
+  <executions>
+    <execution>
+      <goals>
+        <goal>generate</goal>
+        <goal>docs</goal>
+      </goals>
+    </execution>
+  </executions>
+</plugin>
+```
+
+**After (8.1.0).** One `<generator>` entry per language, in the same list as your code
+generators; the `docs` goal and its parameters are gone. These entries write the same pages
+to the same paths as the 8.0 pom above:
+
+```xml
+<plugin>
+  <groupId>com.metaobjects</groupId>
+  <artifactId>metaobjects-maven-plugin</artifactId>
+  <configuration>
+    <loader>...</loader>
+    <generators>
+      <generator>
+        <classname>com.metaobjects.generator.spring.SpringDtoGenerator</classname>
+        <args><outputDir>${project.build.directory}/generated-sources/java</outputDir></args>
+      </generator>
+      <generator>
+        <classname>com.metaobjects.generator.apidocs.JavaApiDocsGenerator</classname>
+        <args>
+          <outputDir>${project.build.directory}/docs</outputDir>
+          <layout>package</layout>
+          <projectName>${project.artifactId}</projectName>
+          <modelBaseUrl>https://docs.example.com/model</modelBaseUrl>
+        </args>
+      </generator>
+      <generator>
+        <classname>com.metaobjects.generator.kotlin.apidocs.KotlinApiDocsGenerator</classname>
+        <args>
+          <outputDir>${project.build.directory}/docs</outputDir>
+          <layout>package</layout>
+          <projectName>${project.artifactId}</projectName>
+          <modelBaseUrl>https://docs.example.com/model</modelBaseUrl>
+        </args>
+      </generator>
+    </generators>
+  </configuration>
+  <executions>
+    <execution>
+      <goals>
+        <goal>generate</goal>
+      </goals>
+    </execution>
+  </executions>
+</plugin>
+```
+
+**Each 8.0 parameter, and where it goes.**
+
+| 8.0 (`metaobjects:docs`) | 8.1.0 (`<args>` of the api-docs entry) |
+|---|---|
+| `<outputDirectory>` (default `${project.build.directory}/docs`) | `outputDir`, required |
+| `<language>` (default `java`) | which entries you list: `JavaApiDocsGenerator` for `java`, `KotlinApiDocsGenerator` for `kotlin` |
+| `<apiSubDir>` (default `api/<language>`) | `apiSubDir`, same default per generator |
+| `<layout>` (default `flat`) | `layout`, same default |
+| `<modelBaseUrl>` | `modelBaseUrl` |
+| the page header's project label, which was the module's `artifactId` | `projectName`, default `project`; set `${project.artifactId}` to keep 8.0's pages byte for byte |
+| `-Dmetaobjects.docs.*` properties | none; use Maven properties inside `<args>` if you need to override from the command line |
+
+**Give each api-docs entry an `outputDir` that holds generated files only.**
+`metaobjects:verify` now checks the pages, as it checks code: it regenerates each entry's
+`outputDir` and compares the whole tree, so a hand-written file there reads as stale.
+
+**Scripts and CI.** Replace `mvn metaobjects:docs` with `mvn metaobjects:generate`. To write
+only the documentation, give it an execution of its own and run that one:
+
+```xml
+<execution>
+  <id>docs</id>
+  <goals><goal>generate</goal></goals>
+  <configuration>
+    <generators>
+      <generator>
+        <classname>com.metaobjects.generator.apidocs.JavaApiDocsGenerator</classname>
+        <args><outputDir>${project.build.directory}/docs</outputDir></args>
+      </generator>
+    </generators>
+  </configuration>
+</execution>
+```
+
+```
+mvn metaobjects:generate@docs
+```
+
+**A generator you own.** An owned api-docs copy (`mvn metaobjects:eject -Dnames=api-docs`)
+is listed by its own class name in `<generators>`, in place of the packaged one. 8.0 had no
+other place to list it.
+
+**Java `entity` no longer writes extractors.** Through 8.0 the `entity` generator
+(`JavaObjectCodeGenerator`) also wrote a `<Name>Extractor` beside each class when the pom
+listed no `extractor`. In 8.1.0 only the `extractor` entry writes them. If your code calls
+`<Name>Extractor.extract(...)` and your pom lists `entity` without `extractor`, add:
+
+```xml
+<generator>
+  <classname>com.metaobjects.generator.direct.object.javacode.ExtractorCodeGenerator</classname>
+  <args>
+    <outputDir>(the entity entry's outputDir)</outputDir>
+  </args>
+</generator>
+```
+
+Give it the same naming args (`pkgPrefix`, `pkgSuffix`, `namePrefix`, `nameSuffix`) and
+`<filters>` as the `entity` entry, so each extractor lands beside its class as before.
+
+**Unchanged.** Poms that list `plantuml`, `html-docs` or `ai-docs` already declared them as
+`<generator>` entries and need nothing.
diff --git a/docs/features/own-your-codegen.md b/docs/features/own-your-codegen.md
index 362332f60..b1e08fdaf 100644
--- a/docs/features/own-your-codegen.md
+++ b/docs/features/own-your-codegen.md
@@ -406,7 +406,7 @@ is **no three-way merge** (TypeScript-only) and **no hash manifest**, so nothing
 notice an edit to a file that still *has* its marker — such a file is overwritten.
 
 **Four write paths bypass the guard on purpose**, and they are not oversights: user-supplied
-templates (`TemplateScopeGenerator`, `MustacheTemplateGenerator`), the Maven docs goal's API
+templates (`TemplateScopeGenerator`, `MustacheTemplateGenerator`), the `api-docs` generators'
 pages, and the `META-INF/services` registration whose entire content is a bare
 fully-qualified name. None of them emits content MetaObjects authors, so none can be
 required to carry a marker — guard one and run 1 writes it while every run after refuses
@@ -894,16 +894,21 @@ The JVM plugin loads generator classes from your project's classpath, but only f
 classes compiled **before** `generate-sources` runs, and the plugin's own copy of a class
 always wins over one with the same name. So eject puts each copy into a separate
 `codegen/` Maven module, under your own package (`-Dpackage`, default
-`<groupId>.codegen`). Every copy compiles on its own, and none calls another generator. The
+`<groupId>.codegen`). The `api-docs` copies alone go one level below it, in a subpackage per
+port ([below](#api-docs-the-api-reference-as-an-owned-generator)). Every copy compiles on its
+own, and none calls another generator. The
 package declaration is the only line it changes, except for a generator that is copied with
-other classes (Java `entity` and `extractor`, below) and for the support imports described
-below: there the imports those copies have of one another change too. On first use
+other classes (the emitters it writes through, below, and Java `entity` and `extractor`) and
+for the support imports and the template prefix described below: there the imports those
+copies have of one another change too. On first use
 it writes `codegen/pom.xml`, which depends on `metaobjects-codegen-spring` or
-`metaobjects-codegen-kotlin` at the plugin's version.
+`metaobjects-codegen-kotlin` at the plugin's version, or on both when that call ejects for both
+ports.
 
-Eject changes a copy's package declaration, and for a Java generator up to two more
-lines, both described below: its import of `SpringGeneratorSupport`, and its
-`RUNTIME_PACKAGE` constant.
+Eject changes a copy's package declaration, and for a Java generator up to three more
+lines, each described below: its import of `SpringGeneratorSupport`, its
+`RUNTIME_PACKAGE` constant, and, for `api-docs`, the classpath prefix its template
+provider reads from.
 
 Eject never edits an existing pom. It prints the three things to wire: the `<module>`
 entry for your parent pom, a plugin `<dependency>` on the codegen module for the module
@@ -935,7 +940,7 @@ flavor, so the writers come with it:
 
 | Copied file | What it holds |
 |---|---|
-| `JavaObjectCodeGenerator` | Which flavors exist and which writer each one gets (`createWriter`); the `ObjectClassBindingProvider` source and its `META-INF/services` registration; whether the `<Name>Extractor` classes are written here. |
+| `JavaObjectCodeGenerator` | Which flavors exist and which writer each one gets (`createWriter`); the `ObjectClassBindingProvider` source and its `META-INF/services` registration. |
 | `JavaCodeGenerator`, `BaseObjectCodeGenerator` | The generator's arguments, and the directory and file name each class lands in. |
 | `BaseObjectCodeWriter` | The class header comment, and the per-field loop every flavor shares. |
 | `JavaCodeWriter` | The Java type of each field; accessor, parameter, class and package names; the body of the interface flavor. |
@@ -949,8 +954,7 @@ field, a constructor or an accessor, edit the writer. You subclass nothing. `-Dl
 What stays in the package holds no emit: `MultiFileDirectGeneratorBase` (the
 one-file-per-object loop), `FileDirectWriter` (indentation and `println`) and
 `GeneratedFileWriter` (the write guard: a file with no `GENERATED` marker is left alone).
-The owned `entity` still calls the packaged `ExtractorCodeGenerator` to write the
-extractors, until you wire an `extractor` generator of your own.
+`entity` writes no extractors; those are the `extractor` generator's, below.
 
 **`extractor` copies three files.** `ExtractorCodeGenerator.java` holds its emit.
 `JavaCodeWriter` and `BaseObjectCodeWriter` come with it because that is where it reads the
@@ -971,16 +975,155 @@ objects: an extractor for an object `entity` wrote no class for does not compile
 </generator>
 ```
 
-`entity` still writes the extractors itself when no separate `extractor` generator is in
-the run, so a pom that wires only `entity` emits what it always did. When one is in
-`<generators>`, the plugin tells `entity` to leave those files to it: it sets
-`emitExtractors` to `false`, whatever the pom says, so each file has one emitter. Outside
-Maven, set `emitExtractors=false` on `entity` yourself.
+`entity` writes no extractors. Through 8.0 it wrote them when no `extractor` was listed,
+which was output no `<generator>` entry declared; 8.1.0 removed that (ADR-0034 Amendment 9).
+A pom with more than one `entity` entry lists one `extractor` entry per `entity` entry, each
+with that entry's `outputDir`, naming args and `<filters>`.
 
-A pom with more than one `entity` entry needs one `extractor` entry per `entity` entry,
-each with that entry's `outputDir`, naming args and `<filters>`. A single `extractor`
-generator in the run stops every `entity` entry writing its extractors, so an `entity`
-entry left without one gets none.
+### Ejecting a generator hands over the emitters it writes through (Java and Kotlin)
+
+A generator that calls an emitter writes part of its output through it. If eject left the
+emitter in the package, the copy would own the orchestration and the package would still own
+the text, and a defect in that text would wait for a release. So eject copies the emitters
+too, into the generator's package, and points the imports the copies have of one another at
+the copies:
+
+| Port | Eject | Also writes |
+|---|---|---|
+| Java | `dto`, `value-object` | `Fr019SharedEnum` (the shared and provided enum files and their type references), `SpringRecordBuilder` (the `builder()` a record carries) |
+| Java | `output-parser` | `Fr019SharedEnum` |
+| Java | `output-prompt` | `OutputFormatSpecEmitter` (the `OutputFormatSpec` literal) |
+| Java | `entity` | the eight files above, `ExtractorCodeGenerator` among them |
+| Kotlin | `entity` | `KotlinEnumEmitter` (the enum class file) |
+| Kotlin | `output-parser` | `KotlinExtractSchemaEmitter` (the extraction mirror and the literal helpers) |
+| Kotlin | `output-prompt` | `KotlinOutputFormatSpecEmitter`, `KotlinExtractSchemaEmitter` |
+| Kotlin | `api-docs` | the page model, builder, renderer and path math, below |
+
+A class two generators share is written once. A later eject finds it, says it is
+`IDENTICAL` or `DIFFERS`, and leaves your edits alone; `-Dforce` replaces it with the reference,
+as it replaces the generator. Each copy is the packaged source with the same package edit
+as the generator and the same import rewrite, and the Java copies carry an explicit import of
+the packaged sibling classes they still call, so they compile from any package.
+
+**What stays in the package is the engine**, public and unchanged: the generator base and
+runner types, the naming and type-mapping tables (`SpringNaming`, `SpringTypeMapper`,
+`KotlinNaming`, `KotlinTypeMapper`), the questions a generator asks of the model
+(`FindInbound`, `TphPlan`, the M:N support, `RestSurfaceGate`), and the Kotlin
+`Fr019SharedEnum`. Anything that returns emitted text is handed over; a table or a model
+question is not. The Kotlin `Fr019SharedEnum` writes no output. It answers where a shared or
+`@provided` enum lives, and the type mapper and the generator utilities take its
+`ProvidedEnumConfig` as an argument, so it is the same kind of thing as a type-mapping table.
+The Java `Fr019SharedEnum` is different: it also writes the enum files, so it is handed over.
+
+The line is written down and checked. `EjectContractTest`, in the Maven plugin for Java and in
+`codegen-kotlin` for Kotlin, ejects each generator the registry lists alone into an empty
+project, compiles it against the published artifacts, fails on any reference to a packaged
+class outside the engine surface in `fixtures/generator-registry-conformance/registry.json`,
+and compares what the copy emits with what the packaged generator emits, byte for byte.
+
+**A copy you ejected before the emitters were handed over** keeps compiling and running, with
+the packaged emitters. A copy made by 1.0.13 compiled against the 1.1.0 package unchanged,
+for the Java generators ejected together (`dto`, `repository`, `value-object`) and for Kotlin
+`entity` and `output-prompt`. A Java `routes`, `dto` or `value-object` ejected alone never
+compiled; that is the 1.0.x defect, and re-ejecting it with `-Dforce=true` is the fix.
+
+To own the emitters, raise your `codegen/` module's dependency on the codegen artifact to
+1.1.0 or later, eject the same names into a scratch project under a package of its own, copy
+the emitter files next to your generators and point the generators at them. Kotlin, for
+`entity` and `output-prompt`:
+
+```bash
+# in a scratch project (any pom), with the 1.1.0 plugin
+mvn metaobjects:eject -Dnames=entity,output-prompt -Dport=kotlin -Dpackage=com.acme.scratch
+# in yours
+d=codegen/src/main/kotlin/com/acme/codegen
+cp scratch/codegen/src/main/kotlin/com/acme/scratch/{KotlinEnumEmitter,KotlinOutputFormatSpecEmitter,KotlinExtractSchemaEmitter}.kt $d/
+sed -i 's/com\.acme\.scratch/com.acme.codegen/g' $d/{KotlinEnumEmitter,KotlinOutputFormatSpecEmitter,KotlinExtractSchemaEmitter}.kt
+sed -i -E 's/^import com\.metaobjects\.generator\.kotlin\.(KotlinEnumEmitter|KotlinOutputFormatSpecEmitter|KotlinExtractSchemaEmitter)$/import com.acme.codegen.\1/' $d/KotlinEntityGenerator.kt $d/KotlinOutputPromptGenerator.kt
+```
+
+Java, for `dto` and `value-object` (Java imports end with `;`, and the copied files need only
+their package line changed):
+
+```bash
+mvn metaobjects:eject -Dnames=dto,value-object -Dport=java -Dpackage=com.acme.scratch   # in the scratch project
+d=codegen/src/main/java/com/acme/codegen
+cp scratch/codegen/src/main/java/com/acme/scratch/{Fr019SharedEnum,SpringRecordBuilder}.java $d/
+sed -i 's/com\.acme\.scratch/com.acme.codegen/g' $d/{Fr019SharedEnum,SpringRecordBuilder}.java
+sed -i -E 's/^import com\.metaobjects\.generator\.spring\.(Fr019SharedEnum|SpringRecordBuilder);/import com.acme.codegen.\1;/' $d/SpringDtoGenerator.java $d/SpringValueObjectGenerator.java
+```
+
+Both were run against copies made by 1.0.13 and built against the 1.1.0 artifacts, and the owned module
+compiled. `mvn metaobjects:eject -Dlist` keeps reporting such a copy as `DIFFERS`, because a copy
+that old differs from the 1.1.0 reference in other lines too, not only in the emitters.
+
+### `api-docs`: the api reference as an owned generator
+
+The `api-docs` generators write the Java and the Kotlin api reference. `mvn metaobjects:eject
+-Dnames=api-docs -Dport=java` copies the generator that writes the Java one, with the page
+model (`ApiSymbol`, `ApiUnit`, `FieldShape`, `ApiSymbolKind`, `JavaApiModel`, `UnitExample`), the
+builder that decides what to document (`JavaApiModelBuilder`, `JavaFieldShapes`), the renderer
+(`JavaApiDocsRenderer`), the path math (`DocsPaths`) and the template provider, and writes the
+page templates into `codegen/src/main/resources/<package path>/apidocs/java/templates/api/`.
+Eject points the copied provider at that directory, so the page text is the one you own and no
+other jar on the classpath can shadow it. `-Dport=kotlin` copies `KotlinApiDocsGenerator`,
+`KotlinApiModel`, `KotlinApiModelBuilder`, `KotlinApiDocsRenderer` and `DocsPaths`; the Kotlin
+renderer writes its pages in code, so it has no templates.
+
+**The copies take a subpackage per port.** The Java copies are written in
+`<package>.apidocs.java` and the Kotlin ones in `<package>.apidocs.kotlin`, where `<package>` is
+`-Dpackage` (default `<groupId>.codegen`). The two ports name their page model and path classes
+alike (`ApiUnit`, `ApiSymbol`, `FieldShape`, `ApiSymbolKind`, `DocsPaths`), so a project that
+documents both surfaces can own both generators in one `codegen/` module without declaring a
+class twice. Eject prints each copy's class name, for example
+`com.acme.codegen.apidocs.java.JavaApiDocsGenerator`. No other generator's package changes.
+
+**The pom builds the ports the module held when eject wrote it.** Eject writes
+`codegen/pom.xml` once and never edits an existing one, so how a module comes to hold both ports
+decides what is left for you to do:
+
+- **Both ports in one call** (a Java-only name beside a Kotlin-only one, for example
+  `-Dnames=html-docs,exposed-table`). The pom eject writes builds both. Nothing to change.
+- **Java first, then Kotlin in a later call.** Add the `metaobjects-codegen-kotlin` dependency,
+  the `kotlin.compiler.jvmTarget` property, and `kotlin-maven-plugin` with `src/main/kotlin` as
+  its `<sourceDirs>`.
+- **Kotlin first, then Java in a later call.** Add the `metaobjects-codegen-spring` dependency,
+  remove `<sourceDirectory>src/main/kotlin</sourceDirectory>` so that Maven compiles
+  `src/main/java` again, and give `kotlin-maven-plugin` `src/main/kotlin` as its `<sourceDirs>`.
+
+In the two later-call orders the module still builds green with the new port's copies left out,
+so eject warns and prints what to add. All three orders end with the same pom: both
+dependencies, Maven's default Java source root, and the Kotlin plugin pointed at its own.
+`-Dforce` rewrites the pom for every port the module holds.
+
+List the copy in `<generators>`, with `<classname>` set to your copy, in place of the packaged
+entry, and `metaobjects:generate` runs it like any other generator (ADR-0034 Amendment 9).
+`outputDir`, `apiSubDir`, `layout`, `projectName` and `modelBaseUrl` are its `<args>`, and the
+pages land under `<outputDir>/<apiSubDir>`. `metaobjects:verify` checks them like code.
+
+**It describes what the packaged generators emit.** The Java reference documents a controller,
+a filter allowlist, a render helper only if the packaged generator that emits it would, which each
+answers through its static `appliesTo`. The builder asks through `GeneratorApplicability`
+(`GeneratorApplicability.packaged()`), never through a generator class, which is why the copy
+depends on nothing but the engine. That holds in a project that owns one of those generators
+too: an owned `routes` whose `appliesTo` you changed is still documented as the packaged one
+behaves. To document your own surface, change the one line of your `JavaApiDocsGenerator` copy
+that builds the `GeneratorApplicability`. The Kotlin builder asks the engine's own gates, which
+the owned Kotlin generators share, so it has nothing to inject.
+
+### The docs, diagram and schema generators (Java)
+
+`plantuml`, `html-docs`, `ai-docs` and `json-schema` were registered, and wirable by class name,
+before they were ejectable. Each is a generator and the writer that emits its file, and eject
+copies both: `PlantUMLGenerator` with `PlantUMLWriter`, `MetaDataHtmlDocumentationGenerator` with
+`MetaDataHtmlDocumentationWriter`, `MetaDataAIDocumentationGenerator` with
+`MetaDataAIDocumentationWriter`, `MetaDataFileJsonSchemaGenerator` with `MetaDataFileSchemaWriter`.
+The generator bases (`SingleFileDirectGeneratorBase`, `SingleJsonDirectGeneratorBase`,
+`SingleHtmlDirectGeneratorBase`) and the writer bases they drive (`JsonDirectWriter`,
+`HtmlDirectWriter`) stay in the package as engine. The attributes the JSON Schema and AI
+documentation generators add to the metamodel are metamodel vocabulary, registered by
+`CodeGenMetaDataProvider` and read by the loader, so they stay in the package too. The old static
+methods on the two generators forward to it.
 
 ### What eject hands over, and what stays core
 
@@ -1096,10 +1239,9 @@ have no edits of your own (`-Dlist` says `identical`), re-eject with `-Dforce`.
 
 `-Dport` is needed only when a name exists in both ports and your project's dependencies
 do not say which. Every Kotlin generator is ejectable. Every Java generator is too, except
-`template`, the deprecated `mustache`, and four that are registered and do not ship eject
-source yet (`plantuml`, `html-docs`, `ai-docs`, `json-schema`). `template` is the Mustache
-primitive: the template you supply is its emit logic, so the generator has none of its own
-to hand over. That holds in every port that ships it.
+`template` and the deprecated `mustache`. `template` is the Mustache primitive: the template you
+supply is its emit logic, so the generator has none of its own to hand over. That holds in every
+port that ships it.
 
 ## C#: `dotnet meta eject`
 
diff --git a/docs/ports/java.md b/docs/ports/java.md
index 41b6a8875..dd5ee060e 100644
--- a/docs/ports/java.md
+++ b/docs/ports/java.md
@@ -265,7 +265,8 @@ into a Maven test (e.g. a JUnit assertion in the `test` phase).
 This table is **complete**: it lists every generator in Java's
 `com.metaobjects.generator.GeneratorRegistry`, and a test fails if the registry gains one
 this page does not name. There is no default suite on the JVM — `<generators>` in the pom
-is the complete list, one `<generator>` entry per generator you want — so a generator
+is the complete list, one `<generator>` entry per generator you want, documentation
+included, and nothing it does not name is written (ADR-0034 Amendment 9) — so a generator
 missing from this page is one an adopter has no way to discover.
 
 The **stable name** is the cross-port spelling pinned in
@@ -281,17 +282,18 @@ name in every port.
 | `value-object` | `SpringValueObjectGenerator` | `metaobjects-codegen-spring` | One Java 21 `record` per concrete `object.value` and per sourceless `object.projection`, in the value object's own package. It carries jakarta bean-validation constraints plus `@Valid` on nested members, so a VO jsonb column POSTs and PATCHes with validation cascading to depth ≥ 2. It is THE Java type for the value object (ADR-0056): `<Entity>Dto` / `<Entity>Patch` bind to it, a render helper takes it, and a response parser returns it. The template tier declares no copy, so it needs this generator in the same run. |
 | `names` | `SpringNamesGenerator` | `metaobjects-codegen-spring` | One `<Entity>Names.java` per object with a declared/inherited primary `source.rdb` — `public static final` physical database name constants (table/view name, schema, per-field columns). See "`<Entity>Names`" below. |
 | `requirement-tests` | `JUnitRequirementTestsGenerator` | `metaobjects-codegen-spring` | Per metamodel package that holds a tested requirement, two files in `testPackage`: `Requirements_<pkgKey>_Witnesses.java` (an interface with one default member per non-skipped test, failing with `unimplemented requirement: ...`) and `Requirements_<pkgKey>_Test.java` (one JUnit Jupiter `@Test` per requirement, calling that member on your `witnessClass`; a planned or retired requirement is `@Disabled`). Args: `testPackage` and `witnessClass` (required), `grain` (`concern` or `member`), `filter` and `renderer` (class names on your project classpath), `warnUncovered`. Your test classpath needs `org.junit.jupiter:junit-jupiter-api`. A model with no requirement writes nothing. See "Requirement tests" below. |
-| `entity` | `JavaObjectCodeGenerator` | `metaobjects-codegen-base` | Flavor-selected via the `flavor` generator arg (`com.metaobjects.generator.direct.object.javacode`). `flavor=pojoAware` emits `class <Name> extends PojoObject` — a concrete `MetaObjectAware` class whose inherited `getMetaData()` back-reference breaks a default Jackson/Gson mapper (see [Serializing generated objects](#serializing-generated-objects) below). `flavor=valueObject` emits a map-backed `class <Name> extends ValueObject` instead. Either flavor also emits a self-registering `ObjectClassBindingProvider`, and a `<Name>Extractor` per concrete class unless the `extractor` generator is wired too. For a plain default-Jackson-friendly type, use the `codegen-spring` record surface instead — never `pojoAware`. |
+| `entity` | `JavaObjectCodeGenerator` | `metaobjects-codegen-base` | Flavor-selected via the `flavor` generator arg (`com.metaobjects.generator.direct.object.javacode`). `flavor=pojoAware` emits `class <Name> extends PojoObject` — a concrete `MetaObjectAware` class whose inherited `getMetaData()` back-reference breaks a default Jackson/Gson mapper (see [Serializing generated objects](#serializing-generated-objects) below). `flavor=valueObject` emits a map-backed `class <Name> extends ValueObject` instead. Either flavor also emits a self-registering `ObjectClassBindingProvider`. It writes no `<Name>Extractor`: list `extractor` for those (8.0 wrote them from `entity` when no `extractor` was listed; see [the migration](../features/migrations/docs-are-generators.md#java-and-kotlin)). For a plain default-Jackson-friendly type, use the `codegen-spring` record surface instead — never `pojoAware`. |
 | `output-parser` | `SpringOutputParserGenerator` | `metaobjects-codegen-spring` | One `<Template>Parser` per **responding** `template.prompt` (ADR-0052: one carrying `@responseRef`) — a Jackson-backed throw-only parser returning the `@responseRef` value object's own record (ADR-0056). FR-006 / ADR-0010; the Java sibling of TS's `outputParser()`. See [FR-006 — response parsing](#fr-006--response-parsing) below. |
 | `output-prompt` | `SpringOutputPromptGenerator` | `metaobjects-codegen-spring` | One `<Template>ResponseFormat` per responding `template.prompt` — a static `renderFormat()` / `renderFormat(PromptOverrides)` pair emitting the output-format prompt fragment (FR-010). The reply's syntax comes from `@responseFormat`, never `@format` (which is the syntax of the rendered prompt BODY). |
 | `render-helper` | `SpringRenderHelperGenerator` | `metaobjects-codegen-spring` | One `<Template>RenderHelper` per `template.output`, wrapping the JVM `Renderer` with a typed `render(payload, provider)`. `@kind: document` renders `@textRef` to a `String`; `@kind: email` renders subject + html (+ optional text) into an `EmailDocument`. **It also runs the mustache↔payload drift check at BUILD time** — an unresolvable text, or one with a non-warning `Verify` error, fails the build rather than emitting. |
 | `extractor` | `ExtractorCodeGenerator` | `metaobjects-codegen-base` | One `<Name>Extractor` per concrete object, wrapping the runtime tolerant extract and turning dirty LLM text into a fully-typed flavored object graph (nested objects + arrays-of-objects populated) in one call. Args: `outputDir`, and the `pkgPrefix` / `pkgSuffix` / `namePrefix` / `nameSuffix` your `entity` generator uses; give it the same `<filters>` too. Needs `entity` with a concrete `flavor` in the same run, since an extractor casts to the flavored class. It names `MetaObjectExtractor` (in `metaobjects-om`) by FQN string only, so `codegen-base` keeps no compile dependency on `om` — the reference resolves on the consumer's classpath. |
 | `trace-helper` | `LlmTraceHelperGenerator` | `metaobjects-codegen-spring` | One `<Entity>TraceHelper` per concrete entity that transitively `extends` `metaobjects::ai::LlmCallBase` **and** nests a `template.prompt` carrying `@responseRef` — a static `record<Entity>(...)` that extracts the typed response, builds the `LlmCallBase` trace row, and persists it. Emits nothing for any other entity. |
 | `template` | `TemplateScopeGenerator` | `metaobjects-codegen-base` | The generic Mustache primitive: walk the model by a named `scope`, render one shared template per walk result, write each file. The declarative alternative to writing a generator class — see [Declarative template-codegen](#declarative-template-codegen-templatescopegenerator) below. It renders through `render.templategen.TemplateGenerator`, the byte-pinned cross-port factory; that factory takes a walk callback and is not itself a `Generator`, so `TemplateScopeGenerator` is the class a pom names. |
-| `plantuml` | `PlantUMLGenerator` | `metaobjects-codegen-plantuml` | One PlantUML class diagram of the object model (`outputDir`, `outputFilename`; `showAttrs`, `showFields`, `showAbstracts`, `drawKeys`, `drawRefs` choose what is drawn). Not ejectable yet. |
-| `html-docs` | `MetaDataHtmlDocumentationGenerator` | `metaobjects-codegen-base` | One HTML page describing the registered metamodel types (`outputDir`, `outputFilename`). It reads the type registry, not your model, so it documents the vocabulary your build loads, providers included. Not ejectable yet. |
-| `ai-docs` | `MetaDataAIDocumentationGenerator` | `metaobjects-codegen-base` | The same type reference as JSON, laid out for an AI reader (`outputDir`, `outputFilename`). Not ejectable yet. |
-| `json-schema` | `MetaDataFileJsonSchemaGenerator` | `metaobjects-codegen-base` | A JSON Schema that validates metadata files, built from the type registry (`outputDir`, `outputFilename`). Not ejectable yet. |
+| `api-docs` | `JavaApiDocsGenerator` | `metaobjects-codegen-spring` | The Java SDK api reference: one page per entity, value object, projection, served report and template, an index and `AGENT-API.md`, under `<outputDir>/<apiSubDir>`. A `<generator>` entry like any other, run by `metaobjects:generate` and checked by `metaobjects:verify`. Args: `outputDir` (required; give it generated files only, since `verify` compares the whole tree), `apiSubDir` (default `api/java`), `layout` (`flat`, the default, or `package`), `projectName` (the agent page's header label, default `project`) and `modelBaseUrl` (absolute base for the links to the model pages; relative when unset). The `metaobjects:docs` goal was removed in 8.1.0 ([migration](../features/migrations/docs-are-generators.md#java-and-kotlin)). Ejectable: the copy takes the page IR, the builder, the renderer, the page paths and the page templates with it. |
+| `plantuml` | `PlantUMLGenerator` | `metaobjects-codegen-plantuml` | One PlantUML class diagram of the object model (`outputDir`, `outputFilename`; `showAttrs`, `showFields`, `showAbstracts`, `drawKeys`, `drawRefs` choose what is drawn). Ejectable: the copy takes `PlantUMLWriter` with it. |
+| `html-docs` | `MetaDataHtmlDocumentationGenerator` | `metaobjects-codegen-base` | One HTML page describing the registered metamodel types (`outputDir`, `outputFilename`). It reads the type registry, not your model, so it documents the vocabulary your build loads, providers included. Ejectable: the copy takes `MetaDataHtmlDocumentationWriter` with it. |
+| `ai-docs` | `MetaDataAIDocumentationGenerator` | `metaobjects-codegen-base` | The same type reference as JSON, laid out for an AI reader (`outputDir`, `outputFilename`). Ejectable: the copy takes `MetaDataAIDocumentationWriter` with it. |
+| `json-schema` | `MetaDataFileJsonSchemaGenerator` | `metaobjects-codegen-base` | A JSON Schema that validates metadata files, built from the type registry (`outputDir`, `outputFilename`). Ejectable: the copy takes `MetaDataFileSchemaWriter` with it. |
 | `mustache` | `MustacheTemplateGenerator` | `metaobjects-codegen-mustache` | Deprecated. The Mustache generator that predates `template`; it stays so a pom that names its class keeps building. Use `template`. It is not ejectable and will not be. |
 
 Wire any generator via the Maven plugin's `<generator>` entry pointing at its class.
@@ -299,17 +301,13 @@ Every one is independently configurable; the typical starting set is
 `SpringControllerGenerator` + `SpringDtoGenerator` + `SpringRepositoryGenerator`
 (controller + DTO + repository).
 
-**`extractor` runs two ways.** Wire only `entity` (with a concrete `flavor`) and it writes
-a `<Name>Extractor` beside every non-abstract class itself, as it always has. Add
-`ExtractorCodeGenerator` as a `<generator>` of its own, which is how the other four ports
-expose it, and that generator writes them instead: the plugin tells `entity` to leave the
-files to it (`emitExtractors=false`, whatever the pom says), so each one has a single
-emitter. You need the
-separate entry only to own the extractor (`mvn metaobjects:eject -Dnames=extractor
--Dport=java`) or to run it with different args. Outside Maven, set `emitExtractors=false`
-on `entity` yourself. A pom with more than one `entity` entry needs one `extractor` entry
-per `entity` entry, each with that entry's `outputDir`, naming args and `<filters>`: a
-single `extractor` generator in the run stops every `entity` entry writing its extractors.
+**Extractors are their own entry.** `ExtractorCodeGenerator` is the one generator that
+writes `<Name>Extractor` classes, as in the other four ports: the pom lists it, or none are
+written. Give it the `entity` entry's `outputDir`, naming args and `<filters>`, so each
+extractor lands beside its class. A pom with more than one `entity` entry lists one
+`extractor` entry per `entity` entry. Through 8.0, `entity` wrote them itself when no
+`extractor` was listed; that was output no entry declared, and 8.1.0 removed it
+(ADR-0034 Amendment 9).
 
 ### Shared and `@provided` enums
 
@@ -363,7 +361,7 @@ mvn metaobjects:eject -Dnames=value-object,output-parser -Dport=java -Dforce
 the copy and rewrites `codegen/pom.xml`, so review both diffs. For an edited copy, diff the new
 reference against it and apply the hunks by hand, as in
 [Pulling an upstream fix into your copy](../features/own-your-codegen.md#what-eject-hands-over-and-what-stays-core).
-An owned `dto` copy needs nothing for this: it asks the packaged `Fr019SharedEnum` helper for
+An owned `dto` copy needs nothing for this: it carries its own `Fr019SharedEnum` and asks it for
 each enum's type, so it follows the new rule without a change.
 
 ### Reports
@@ -585,9 +583,9 @@ copy imports them. The model and the other ports' spelling are in
 
 ### Authoring your own — two paths
 
-**Own a generator.** `mvn metaobjects:eject -Dnames=<name,...>` copies a reference generator into a `codegen/` Maven module under your own package, and prints the module, dependency and `<classname>` to wire. See [Own your codegen → Java and Kotlin](../features/own-your-codegen.md#java-and-kotlin-mvn-metaobjectseject). Every generator in the table above can be ejected except `template`.
+**Own a generator.** `mvn metaobjects:eject -Dnames=<name,...>` copies a reference generator into a `codegen/` Maven module under your own package, and prints the module, dependency and `<classname>` to wire. See [Own your codegen → Java and Kotlin](../features/own-your-codegen.md#java-and-kotlin-mvn-metaobjectseject). Every generator in the table above can be ejected except `template` and the deprecated `mustache` (see [the primitive](../features/own-your-codegen.md#java-and-kotlin-mvn-metaobjectseject)).
 
-**`entity` and `extractor` eject from `metaobjects-codegen-base`, each with the rest of its emit.** `mvn metaobjects:eject -Dnames=entity,extractor -Dport=java` (pass `-Dport`: both names are ejectable on both JVM ports). `entity` copies seven files into one package: `JavaObjectCodeGenerator`, the bases it extends (`JavaCodeGenerator`, `BaseObjectCodeGenerator`) and the four writers that emit each class body (`BaseObjectCodeWriter`, `JavaCodeWriter`, `PojoAwareCodeWriter`, `ValueObjectCodeWriter`). The copies use one another, never the packaged classes, so you change a field, a constructor or an accessor by editing the writer. `extractor` copies `ExtractorCodeGenerator` with `JavaCodeWriter` and `BaseObjectCodeWriter`, where it reads class names from; in the same package as `entity` the two share that one copy. The file-by-file table is in [Own your codegen → Java `entity` and `extractor`](../features/own-your-codegen.md#java-entity-and-extractor).
+**`entity` and `extractor` eject from `metaobjects-codegen-base`, each with the rest of its emit.** `mvn metaobjects:eject -Dnames=entity,extractor -Dport=java` (pass `-Dport`: both names are ejectable on both JVM ports). `entity` copies seven files into one package: `JavaObjectCodeGenerator`, the bases it extends (`JavaCodeGenerator`, `BaseObjectCodeGenerator`) and the four writers that emit each class body (`BaseObjectCodeWriter`, `JavaCodeWriter`, `PojoAwareCodeWriter`, `ValueObjectCodeWriter`). The copies use one another, never the packaged classes, so you change a field, a constructor or an accessor by editing the writer. `extractor` copies `ExtractorCodeGenerator` with `JavaCodeWriter` and `BaseObjectCodeWriter`, where it reads class names from; in the same package as `entity` the two share those writers. The file-by-file table is in [Own your codegen → Java `entity` and `extractor`](../features/own-your-codegen.md#java-entity-and-extractor).
 
 **Class headers changed once, and `mvn metaobjects:verify` no longer depends on the clock.** The header comment of every class `entity` writes used to carry an `ObjectCodeWriter:` line (the writer's class name) and a `Generated On:` line (the wall-clock second of the run). Both are gone, so the first regeneration after upgrading changes every generated class file in its header comment and nowhere else. Because of the timestamp, `mvn metaobjects:verify` reported `[content-differs]` for every one of those files unless it ran in the same second as the generate it was checking. Output now holds nothing that varies between runs: regenerating an unchanged model writes the same bytes, and verify passes whenever it runs.
 
diff --git a/docs/ports/kotlin.md b/docs/ports/kotlin.md
index aa3e8e4d6..b0a114a69 100644
--- a/docs/ports/kotlin.md
+++ b/docs/ports/kotlin.md
@@ -9,7 +9,7 @@ wiring) via KotlinPoet.
 
 Two modules:
 
-- **`metaobjects-codegen-kotlin`** — 15 KotlinPoet-based generators.
+- **`metaobjects-codegen-kotlin`** — 16 KotlinPoet-based generators.
 - **`metaobjects-metadata-ktx`** — thin Kotlin facade over the Java loader + render
   engine for idiomatic Kotlin runtime use.
 
@@ -88,7 +88,7 @@ Two modules:
 
 ## Configure
 
-The 15 generators registered in `codegen-kotlin` (`GeneratorRegistry.kt`):
+The 16 generators registered in `codegen-kotlin` (`GeneratorRegistry.kt`):
 
 | Generator | Output | Per |
 |---|---|---|
@@ -107,6 +107,7 @@ The 15 generators registered in `codegen-kotlin` (`GeneratorRegistry.kt`):
 | `KotlinStoredProcGenerator` | Stored-procedure call wrappers | entities with `source.rdb @kind="storedProc"` |
 | `KotlinSpringControllerGenerator` | `<Entity>Controller.kt` — Spring `@RestController` (5 CRUD endpoints; cross-port API contract). **Select `KotlinRelationsGenerator` with it** when the model has a M:N relationship: the traversal routes call the `<rel>Query` helpers only that generator emits, and without it the controller does not compile | entities with `source.rdb @kind="table"` |
 | `KotlinRequirementTestsGenerator` | Per metamodel package that holds a tested requirement, two files in `testPackage`: `Requirements_<pkgKey>_Witnesses.kt` (an interface whose default members fail with `unimplemented requirement: ...`) and `Requirements_<pkgKey>_Test.kt` (one JUnit Jupiter `@Test` per requirement, calling a project-owned witness). See "Requirement tests" below | every tested `requirement.*` (functional, level 4 or above by default) |
+| `KotlinApiDocsGenerator` | The Kotlin SDK api reference, under `<outputDir>/<apiSubDir>`: `<Unit>.md` per entity, value object, projection, served report and template, a `README.md` index and `AGENT-API.md`. A `<generator>` entry like any other, run by `metaobjects:generate` and checked by `metaobjects:verify`. Args: `outputDir` (required, generated files only), `apiSubDir` (default `api/kotlin`), `layout` (`flat` or `package`), `projectName` and `modelBaseUrl`, as for the Java `api-docs`. The `metaobjects:docs` goal was removed in 8.1.0 ([migration](../features/migrations/docs-are-generators.md#java-and-kotlin)). Ejectable, with the page model, builder, renderer and path math | the whole model, once |
 
 Maven wiring:
 
@@ -177,11 +178,13 @@ A requirement that becomes live adds a failing member (a red test, no compile br
 
 **Own a generator.** `mvn metaobjects:eject -Dnames=<name,...>` copies a reference generator into a `codegen/` Maven module under your own package, and prints the module, dependency and `<classname>` to wire. See [Own your codegen → Java and Kotlin](../features/own-your-codegen.md#java-and-kotlin-mvn-metaobjectseject).
 
+**Ejecting hands over the emitters a generator writes through.** `entity` takes `KotlinEnumEmitter` with it, `output-parser` takes `KotlinExtractSchemaEmitter`, and `output-prompt` takes `KotlinOutputFormatSpecEmitter` and `KotlinExtractSchemaEmitter`, into the same package, with the imports the copies have of one another pointed at the copies. `Fr019SharedEnum` stays in the package: it writes nothing and the type mapper takes its `ProvidedEnumConfig` as an argument. See [Own your codegen → emitters](../features/own-your-codegen.md#ejecting-a-generator-hands-over-the-emitters-it-writes-through-java-and-kotlin).
+
 **Nothing else to hand over.** Unlike the Java `routes`/`dto`/`repository` output, no Kotlin generator's output imports helper runtime. The generated controller declares its filter parser, constraint mapping and patch handling inline, per file, and the rest imports only core: render and extract, the loader, and `metadata-ktx`. So an ejected Kotlin generator's output depends on nothing you do not own beyond the core. `EjectRuntimeRoundTripTest` in the Maven plugin checks this against every Kotlin generator's real output. `com.metaobjects.generator.kotlin.runtime.M2mJoinResolver` is a helper you may call from hand-written traversal code. No generated file imports it, so eject does not copy it; copy it yourself if you use it and want to own it.
 
 ### Declarative template-codegen (`TemplateScopeGenerator`)
 
-The 15 generators above are a starting point, not the ceiling. When you need a shape
+The 16 generators above are a starting point, not the ceiling. When you need a shape
 none of them emits, Kotlin has **both** authoring paths — and which to reach for is a
 real decision (tradeoff table: [`codegen-concepts.md` §3](../features/codegen-concepts.md)).
 
@@ -260,7 +263,7 @@ A `field.enum` declared `@provided` is your own enum class: MetaObjects never ge
 and every generated reference points at the namespace you configure. Every Kotlin generator
 that types an enum reads the same two args: `KotlinEntityGenerator`,
 `KotlinExposedTableGenerator`, `KotlinSpringControllerGenerator`, `KotlinRelationsGenerator`,
-`KotlinOutputParserGenerator`, and the API pages `mvn metaobjects:docs` writes. Set them once,
+`KotlinOutputParserGenerator`, and `KotlinApiDocsGenerator`. Set them once,
 in the plugin's `<globals>`, so no generator can be left out:
 
 ```xml
diff --git a/fixtures/agent-context-conformance/java-kotlin-react-tanstack/expected/.claude/skills/metaobjects-codegen/references/java.md b/fixtures/agent-context-conformance/java-kotlin-react-tanstack/expected/.claude/skills/metaobjects-codegen/references/java.md
index d8e1855ab..c02465c15 100644
--- a/fixtures/agent-context-conformance/java-kotlin-react-tanstack/expected/.claude/skills/metaobjects-codegen/references/java.md
+++ b/fixtures/agent-context-conformance/java-kotlin-react-tanstack/expected/.claude/skills/metaobjects-codegen/references/java.md
@@ -10,7 +10,7 @@ Maven plugin goal — there is no standalone `meta` binary on the Java side (the
 - Run
 - Write your own generator
 - When a generator's output is wrong — own the generator
-- Docs — `mvn metaobjects:docs`
+- Docs — the `api-docs` generator
 - `codegen-spring` generators
 - Discriminator inheritance (TPH)
 - Serializing generated objects
@@ -138,16 +138,24 @@ repository.
 When a later MetaObjects release changes the reference generator, diff it against your
 copy and take what you want. Nothing in your build changes until you do.
 
-## Docs — `mvn metaobjects:docs`
+## Docs — the `api-docs` generator
 
-A separate `docs` goal (`DocsMojo` — NOT a `<generator>`) emits this project's SDK api
-surface (default `target/docs/api/java`), including `AGENT-API.md` — the exact imports,
-signatures, and payload field shapes for the generated code.
+The SDK api reference is a `<generator>` entry like any other, run by
+`mvn metaobjects:generate`. It writes `AGENT-API.md` — the exact imports, signatures, and
+payload field shapes for the generated code — plus a page per entity, under
+`<outputDir>/api/java`. Nothing writes it unless the pom lists it; there is no docs goal
+(removed in 8.1.0).
 
-```bash
-mvn metaobjects:docs   # → target/docs/api/java (AGENT-API.md + per-entity pages)
+```xml
+<generator>
+  <classname>com.metaobjects.generator.apidocs.JavaApiDocsGenerator</classname>
+  <args><outputDir>${project.build.directory}/docs</outputDir></args>
+</generator>
 ```
 
+Optional `<args>`: `apiSubDir` (default `api/java`), `layout` (`flat` or `package`),
+`projectName`, `modelBaseUrl`. Give it an `outputDir` of generated files only.
+
 **Before calling any generated code, read `api/java/AGENT-API.md`** — it carries the
 concrete imports and signatures so you don't have to guess them.
 
@@ -170,8 +178,8 @@ separate `metaobjects-codegen-base` module instead.)
 | `LlmTraceHelperGenerator` | `<Entity>TraceHelper.java` per concrete entity — the LLM-trace helper |
 | `SpringFilterAllowlistGenerator` | per-entity filter allowlist |
 | `SpringNamesGenerator` | `<Entity>Names.java` — `public abstract class` of `static final String` names that MIRRORS THE METADATA TREE. Every node carries its own `TYPE`/`SUB_TYPE`/`NAME`, so `AuthorNames.NAME` is the OBJECT's name (`"Author"`), **not** a table name, and a physical name sits under the member that says what it is: `SOURCE_<ROLE>_TABLE` / `_VIEW` / `_MATERIALIZED_VIEW` / `_PROC` / `_FUNCTION`, from the metamodel's own `@kind`-to-alias map, with `<ROLE>` being `PRIMARY` or `REPLICA` (a write-through entity has a member for each). Plus a `<FIELD>_FIELD`/`<FIELD>_COLUMN` pair per field and a complete `COLUMNS_BY_FIELD`; an `identity.secondary` or `index.lookup` also carries `IDENTITY_<NAME>_INDEX` / `INDEX_<NAME>_INDEX`, while `identity.primary` deliberately carries no index member (migrate names a PK by a dialect-conditional formula this artifact must not restate). **There is no `READ_ONLY`** — it was a derivation over `@kind`, never metadata, so ask `SOURCE_<ROLE>_KIND`. Emitted for every object with a declared or inherited primary source, PLUS a fragment for any abstract base such an object extends (columns only, no source). A class whose object extends another one **extends** it (`class CopayAuthNames extends AuthNames`) rather than restating its constants — Java inherits static members, so `CopayAuthNames.SOURCE_PRIMARY_TABLE` and `CopayAuthNames.ID_COLUMN` both resolve through the base. **This port generates no SQL** (the repository is an interface you implement), so nothing generated consumes these — they exist for your implementation. |
-| `JavaObjectCodeGenerator` | module `metaobjects-codegen-base` (`com.metaobjects.generator.direct.object.javacode`), a separate module from the Spring generators above. Flavor-selected via the `flavor` generator arg. `flavor=pojoAware` → `class <Name> extends PojoObject` (a concrete `MetaObjectAware` class with a `(MetaObject)` constructor) — its inherited `getMetaData()` back-reference is what breaks a default Jackson/Gson mapper, see "Serializing generated objects" below. `flavor=valueObject` → `class <Name> extends ValueObject` (map-backed; less hostile to a default mapper, but still not the sanctioned serialization path). Either concrete flavor also emits a self-registering `ObjectClassBindingProvider`, and a `<Name>Extractor` per concrete class unless `ExtractorCodeGenerator` is wired too. For a plain default-Jackson-friendly type, use the `codegen-spring` record surface instead — never `pojoAware`. |
-| `ExtractorCodeGenerator` | also in `metaobjects-codegen-base`. One `<Name>Extractor` per concrete object, the same files `JavaObjectCodeGenerator` writes when this is not wired. Wire it as its own `<generator>` only to own it or to give it different args: same `outputDir`, `pkgPrefix` / `pkgSuffix` / `namePrefix` / `nameSuffix` and `<filters>` as the entity generator, which must run a concrete flavor in the same `<generators>` (an extractor for an object the entity generator wrote no class for does not compile). The plugin then stops the entity generator writing them. A pom with more than one entity generator entry needs one `ExtractorCodeGenerator` entry per entity entry, each with that entry's `outputDir`, naming args and `<filters>`: a single extractor generator in the run stops every entity entry writing its extractors. |
+| `JavaObjectCodeGenerator` | module `metaobjects-codegen-base` (`com.metaobjects.generator.direct.object.javacode`), a separate module from the Spring generators above. Flavor-selected via the `flavor` generator arg. `flavor=pojoAware` → `class <Name> extends PojoObject` (a concrete `MetaObjectAware` class with a `(MetaObject)` constructor) — its inherited `getMetaData()` back-reference is what breaks a default Jackson/Gson mapper, see "Serializing generated objects" below. `flavor=valueObject` → `class <Name> extends ValueObject` (map-backed; less hostile to a default mapper, but still not the sanctioned serialization path). Either concrete flavor also emits a self-registering `ObjectClassBindingProvider`; it writes no extractors. For a plain default-Jackson-friendly type, use the `codegen-spring` record surface instead — never `pojoAware`. |
+| `ExtractorCodeGenerator` | also in `metaobjects-codegen-base`. One `<Name>Extractor` per concrete object, and the only generator that writes them: list it or get none. Give it the same `outputDir`, `pkgPrefix` / `pkgSuffix` / `namePrefix` / `nameSuffix` and `<filters>` as the entity generator, which must run a concrete flavor in the same `<generators>` (an extractor for an object the entity generator wrote no class for does not compile). A pom with more than one entity generator entry needs one `ExtractorCodeGenerator` entry per entity entry, each with that entry's `outputDir`, naming args and `<filters>`. |
 
 **Owning one of these two.** `mvn metaobjects:eject -Dnames=entity,extractor -Dport=java`
 copies each generator into the `codegen/` module with the rest of its emit (`-Dport` is
diff --git a/fixtures/agent-context-conformance/java-kotlin-react-tanstack/expected/.claude/skills/metaobjects-codegen/references/kotlin.md b/fixtures/agent-context-conformance/java-kotlin-react-tanstack/expected/.claude/skills/metaobjects-codegen/references/kotlin.md
index 64b67df90..0f470d98a 100644
--- a/fixtures/agent-context-conformance/java-kotlin-react-tanstack/expected/.claude/skills/metaobjects-codegen/references/kotlin.md
+++ b/fixtures/agent-context-conformance/java-kotlin-react-tanstack/expected/.claude/skills/metaobjects-codegen/references/kotlin.md
@@ -136,17 +136,24 @@ repository.
 When a later MetaObjects release changes the reference generator, diff it against your
 copy and take what you want. Nothing in your build changes until you do.
 
-## Docs — `mvn metaobjects:docs -Dmetaobjects.docs.language=kotlin`
+## Docs — the `api-docs` generator
 
-The shared `docs` goal (`DocsMojo`) renders the Kotlin SDK api surface via
-`KotlinApiDocsRenderer` when pointed at the Kotlin language (default `target/docs/api/kotlin`),
-including `AGENT-API.md` — the exact imports, signatures, and payload field shapes for the
-generated code.
+The Kotlin SDK api reference is a `<generator>` entry like any other, run by
+`mvn metaobjects:generate`. It writes `AGENT-API.md` — the exact imports, signatures, and
+payload field shapes for the generated code — plus a page per entity, under
+`<outputDir>/api/kotlin`. Nothing writes it unless the pom lists it; there is no docs goal
+(removed in 8.1.0).
 
-```bash
-mvn metaobjects:docs -Dmetaobjects.docs.language=kotlin   # → target/docs/api/kotlin (AGENT-API.md + per-entity pages)
+```xml
+<generator>
+  <classname>com.metaobjects.generator.kotlin.apidocs.KotlinApiDocsGenerator</classname>
+  <args><outputDir>${project.build.directory}/docs</outputDir></args>
+</generator>
 ```
 
+Optional `<args>`: `apiSubDir` (default `api/kotlin`), `layout` (`flat` or `package`),
+`projectName`, `modelBaseUrl`. Give it an `outputDir` of generated files only.
+
 **Before calling any generated code, read `api/kotlin/AGENT-API.md`.**
 
 ## `codegen-kotlin` generators
diff --git a/fixtures/agent-context-conformance/java-react/expected/.claude/skills/metaobjects-codegen/references/java.md b/fixtures/agent-context-conformance/java-react/expected/.claude/skills/metaobjects-codegen/references/java.md
index d8e1855ab..c02465c15 100644
--- a/fixtures/agent-context-conformance/java-react/expected/.claude/skills/metaobjects-codegen/references/java.md
+++ b/fixtures/agent-context-conformance/java-react/expected/.claude/skills/metaobjects-codegen/references/java.md
@@ -10,7 +10,7 @@ Maven plugin goal — there is no standalone `meta` binary on the Java side (the
 - Run
 - Write your own generator
 - When a generator's output is wrong — own the generator
-- Docs — `mvn metaobjects:docs`
+- Docs — the `api-docs` generator
 - `codegen-spring` generators
 - Discriminator inheritance (TPH)
 - Serializing generated objects
@@ -138,16 +138,24 @@ repository.
 When a later MetaObjects release changes the reference generator, diff it against your
 copy and take what you want. Nothing in your build changes until you do.
 
-## Docs — `mvn metaobjects:docs`
+## Docs — the `api-docs` generator
 
-A separate `docs` goal (`DocsMojo` — NOT a `<generator>`) emits this project's SDK api
-surface (default `target/docs/api/java`), including `AGENT-API.md` — the exact imports,
-signatures, and payload field shapes for the generated code.
+The SDK api reference is a `<generator>` entry like any other, run by
+`mvn metaobjects:generate`. It writes `AGENT-API.md` — the exact imports, signatures, and
+payload field shapes for the generated code — plus a page per entity, under
+`<outputDir>/api/java`. Nothing writes it unless the pom lists it; there is no docs goal
+(removed in 8.1.0).
 
-```bash
-mvn metaobjects:docs   # → target/docs/api/java (AGENT-API.md + per-entity pages)
+```xml
+<generator>
+  <classname>com.metaobjects.generator.apidocs.JavaApiDocsGenerator</classname>
+  <args><outputDir>${project.build.directory}/docs</outputDir></args>
+</generator>
 ```
 
+Optional `<args>`: `apiSubDir` (default `api/java`), `layout` (`flat` or `package`),
+`projectName`, `modelBaseUrl`. Give it an `outputDir` of generated files only.
+
 **Before calling any generated code, read `api/java/AGENT-API.md`** — it carries the
 concrete imports and signatures so you don't have to guess them.
 
@@ -170,8 +178,8 @@ separate `metaobjects-codegen-base` module instead.)
 | `LlmTraceHelperGenerator` | `<Entity>TraceHelper.java` per concrete entity — the LLM-trace helper |
 | `SpringFilterAllowlistGenerator` | per-entity filter allowlist |
 | `SpringNamesGenerator` | `<Entity>Names.java` — `public abstract class` of `static final String` names that MIRRORS THE METADATA TREE. Every node carries its own `TYPE`/`SUB_TYPE`/`NAME`, so `AuthorNames.NAME` is the OBJECT's name (`"Author"`), **not** a table name, and a physical name sits under the member that says what it is: `SOURCE_<ROLE>_TABLE` / `_VIEW` / `_MATERIALIZED_VIEW` / `_PROC` / `_FUNCTION`, from the metamodel's own `@kind`-to-alias map, with `<ROLE>` being `PRIMARY` or `REPLICA` (a write-through entity has a member for each). Plus a `<FIELD>_FIELD`/`<FIELD>_COLUMN` pair per field and a complete `COLUMNS_BY_FIELD`; an `identity.secondary` or `index.lookup` also carries `IDENTITY_<NAME>_INDEX` / `INDEX_<NAME>_INDEX`, while `identity.primary` deliberately carries no index member (migrate names a PK by a dialect-conditional formula this artifact must not restate). **There is no `READ_ONLY`** — it was a derivation over `@kind`, never metadata, so ask `SOURCE_<ROLE>_KIND`. Emitted for every object with a declared or inherited primary source, PLUS a fragment for any abstract base such an object extends (columns only, no source). A class whose object extends another one **extends** it (`class CopayAuthNames extends AuthNames`) rather than restating its constants — Java inherits static members, so `CopayAuthNames.SOURCE_PRIMARY_TABLE` and `CopayAuthNames.ID_COLUMN` both resolve through the base. **This port generates no SQL** (the repository is an interface you implement), so nothing generated consumes these — they exist for your implementation. |
-| `JavaObjectCodeGenerator` | module `metaobjects-codegen-base` (`com.metaobjects.generator.direct.object.javacode`), a separate module from the Spring generators above. Flavor-selected via the `flavor` generator arg. `flavor=pojoAware` → `class <Name> extends PojoObject` (a concrete `MetaObjectAware` class with a `(MetaObject)` constructor) — its inherited `getMetaData()` back-reference is what breaks a default Jackson/Gson mapper, see "Serializing generated objects" below. `flavor=valueObject` → `class <Name> extends ValueObject` (map-backed; less hostile to a default mapper, but still not the sanctioned serialization path). Either concrete flavor also emits a self-registering `ObjectClassBindingProvider`, and a `<Name>Extractor` per concrete class unless `ExtractorCodeGenerator` is wired too. For a plain default-Jackson-friendly type, use the `codegen-spring` record surface instead — never `pojoAware`. |
-| `ExtractorCodeGenerator` | also in `metaobjects-codegen-base`. One `<Name>Extractor` per concrete object, the same files `JavaObjectCodeGenerator` writes when this is not wired. Wire it as its own `<generator>` only to own it or to give it different args: same `outputDir`, `pkgPrefix` / `pkgSuffix` / `namePrefix` / `nameSuffix` and `<filters>` as the entity generator, which must run a concrete flavor in the same `<generators>` (an extractor for an object the entity generator wrote no class for does not compile). The plugin then stops the entity generator writing them. A pom with more than one entity generator entry needs one `ExtractorCodeGenerator` entry per entity entry, each with that entry's `outputDir`, naming args and `<filters>`: a single extractor generator in the run stops every entity entry writing its extractors. |
+| `JavaObjectCodeGenerator` | module `metaobjects-codegen-base` (`com.metaobjects.generator.direct.object.javacode`), a separate module from the Spring generators above. Flavor-selected via the `flavor` generator arg. `flavor=pojoAware` → `class <Name> extends PojoObject` (a concrete `MetaObjectAware` class with a `(MetaObject)` constructor) — its inherited `getMetaData()` back-reference is what breaks a default Jackson/Gson mapper, see "Serializing generated objects" below. `flavor=valueObject` → `class <Name> extends ValueObject` (map-backed; less hostile to a default mapper, but still not the sanctioned serialization path). Either concrete flavor also emits a self-registering `ObjectClassBindingProvider`; it writes no extractors. For a plain default-Jackson-friendly type, use the `codegen-spring` record surface instead — never `pojoAware`. |
+| `ExtractorCodeGenerator` | also in `metaobjects-codegen-base`. One `<Name>Extractor` per concrete object, and the only generator that writes them: list it or get none. Give it the same `outputDir`, `pkgPrefix` / `pkgSuffix` / `namePrefix` / `nameSuffix` and `<filters>` as the entity generator, which must run a concrete flavor in the same `<generators>` (an extractor for an object the entity generator wrote no class for does not compile). A pom with more than one entity generator entry needs one `ExtractorCodeGenerator` entry per entity entry, each with that entry's `outputDir`, naming args and `<filters>`. |
 
 **Owning one of these two.** `mvn metaobjects:eject -Dnames=entity,extractor -Dport=java`
 copies each generator into the `codegen/` module with the rest of its emit (`-Dport` is
diff --git a/fixtures/generator-registry-conformance/registry.json b/fixtures/generator-registry-conformance/registry.json
index d5e49a450..5f5a58876 100644
--- a/fixtures/generator-registry-conformance/registry.json
+++ b/fixtures/generator-registry-conformance/registry.json
@@ -107,7 +107,7 @@
       "concept": "Per-entity/template SDK API reference (generated-code API; human + agent forms).",
       "tier": "native",
       "layer": "docs",
-      "note": "Run by the port's docs command (`meta docs`, `dotnet meta docs`, `mvn metaobjects:docs`, `metaobjects docs`) as its api surface (ADR-0025), not by the gen command: a TypeScript `meta gen` config that lists it is warned about and skipped, and `dotnet meta gen` skips it, warning only when `--generators` names it.",
+      "note": "An ordinary generator, listed in the project's generator list and run by the gen command (ADR-0034 Amendment 9). Java and Kotlin do this today: a `<generator>` entry that `mvn metaobjects:generate` runs. TypeScript, C# and Python still run it from the port's docs command (`meta docs`, `dotnet meta docs`, `metaobjects docs`), and their gen commands skip it, until each port's Amendment 9 change lands and removes that command.",
       "eject": "full",
       "ports": ["typescript", "csharp", "java", "kotlin", "python"]
     },
@@ -362,7 +362,7 @@
       "java": {
         "codegenPackages": ["com.metaobjects.generator.**"],
         "engine": [
-          "com.metaobjects.generator.EmitsObjectExtractors",
+          "com.metaobjects.generator.CodeGenMetaDataProvider",
           "com.metaobjects.generator.EmitsPhysicalNameConstants",
           "com.metaobjects.generator.FileEmittingGenerator",
           "com.metaobjects.generator.Generator",
@@ -372,9 +372,15 @@
           "com.metaobjects.generator.GeneratorIOWriter",
           "com.metaobjects.generator.MetaDataFilters",
           "com.metaobjects.generator.ProjectClassLoaderAware",
+          "com.metaobjects.generator.apidocs.GeneratorApplicability",
           "com.metaobjects.generator.direct.FileDirectWriter",
           "com.metaobjects.generator.direct.GenerationContext",
           "com.metaobjects.generator.direct.MultiFileDirectGeneratorBase",
+          "com.metaobjects.generator.direct.SingleFileDirectGeneratorBase",
+          "com.metaobjects.generator.direct.metadata.html.HtmlDirectWriter",
+          "com.metaobjects.generator.direct.metadata.html.SingleHtmlDirectGeneratorBase",
+          "com.metaobjects.generator.direct.metadata.json.JsonDirectWriter",
+          "com.metaobjects.generator.direct.metadata.json.SingleJsonDirectGeneratorBase",
           "com.metaobjects.generator.direct.object.BaseObjectCodeGenerator",
           "com.metaobjects.generator.requirement.RenderedTest",
           "com.metaobjects.generator.requirement.RequirementTestArgs",
@@ -405,6 +411,7 @@
           "com.metaobjects.generator.kotlin.ExposedApi",
           "com.metaobjects.generator.kotlin.ExposedImports",
           "com.metaobjects.generator.kotlin.FindInbound",
+          "com.metaobjects.generator.kotlin.Fr019SharedEnum",
           "com.metaobjects.generator.kotlin.KotlinGenUtil",
           "com.metaobjects.generator.kotlin.KotlinM2mSupport",
           "com.metaobjects.generator.kotlin.KotlinNaming",
@@ -450,78 +457,6 @@
       }
     ],
     "pending": [
-      {"generator": "api-docs", "port": "java", "assertion": "census", "gap": 6},
-      {"generator": "api-docs", "port": "kotlin", "assertion": "census", "gap": 6},
-      {"generator": "ai-docs", "port": "java", "assertion": "completeness", "gap": 7},
-      {"generator": "html-docs", "port": "java", "assertion": "completeness", "gap": 7},
-      {"generator": "json-schema", "port": "java", "assertion": "completeness", "gap": 7},
-      {"generator": "plantuml", "port": "java", "assertion": "completeness", "gap": 7},
-      {
-        "generator": "dto",
-        "port": "java",
-        "assertion": "depth",
-        "gap": 5,
-        "outside": ["com.metaobjects.generator.spring.Fr019SharedEnum", "com.metaobjects.generator.spring.SpringRecordBuilder"]
-      },
-      {
-        "generator": "entity",
-        "port": "java",
-        "assertion": "depth",
-        "gap": 13,
-        "outside": ["com.metaobjects.generator.direct.object.javacode.ExtractorCodeGenerator"]
-      },
-      {"generator": "output-parser", "port": "java", "assertion": "depth", "gap": 5, "outside": ["com.metaobjects.generator.spring.Fr019SharedEnum"]},
-      {
-        "generator": "output-prompt",
-        "port": "java",
-        "assertion": "depth",
-        "gap": 4,
-        "outside": ["com.metaobjects.generator.spring.OutputFormatSpecEmitter"]
-      },
-      {
-        "generator": "value-object",
-        "port": "java",
-        "assertion": "depth",
-        "gap": 5,
-        "outside": ["com.metaobjects.generator.spring.Fr019SharedEnum", "com.metaobjects.generator.spring.SpringRecordBuilder"]
-      },
-      {
-        "generator": "entity",
-        "port": "kotlin",
-        "assertion": "depth",
-        "gap": 5,
-        "outside": ["com.metaobjects.generator.kotlin.Fr019SharedEnum", "com.metaobjects.generator.kotlin.KotlinEnumEmitter"]
-      },
-      {
-        "generator": "exposed-table",
-        "port": "kotlin",
-        "assertion": "depth",
-        "gap": 5,
-        "outside": ["com.metaobjects.generator.kotlin.Fr019SharedEnum"]
-      },
-      {
-        "generator": "output-parser",
-        "port": "kotlin",
-        "assertion": "depth",
-        "gap": 4,
-        "outside": ["com.metaobjects.generator.kotlin.KotlinExtractSchemaEmitter"]
-      },
-      {
-        "generator": "output-parser",
-        "port": "kotlin",
-        "assertion": "depth",
-        "gap": 5,
-        "outside": ["com.metaobjects.generator.kotlin.Fr019SharedEnum"]
-      },
-      {
-        "generator": "output-prompt",
-        "port": "kotlin",
-        "assertion": "depth",
-        "gap": 4,
-        "outside": ["com.metaobjects.generator.kotlin.KotlinOutputFormatSpecEmitter"]
-      },
-      {"generator": "relations", "port": "kotlin", "assertion": "depth", "gap": 5, "outside": ["com.metaobjects.generator.kotlin.Fr019SharedEnum"]},
-      {"generator": "routes", "port": "kotlin", "assertion": "depth", "gap": 5, "outside": ["com.metaobjects.generator.kotlin.Fr019SharedEnum"]},
       {
         "generator": "entity",
         "port": "typescript",
diff --git a/server/java/README.md b/server/java/README.md
index a9967dd45..55a56ddbd 100644
--- a/server/java/README.md
+++ b/server/java/README.md
@@ -12,7 +12,7 @@ Only the loader and registry, runtime metadata access and the drift gates are a
 guarantee. The generators are reference helpers: copy one into your build with
 `mvn metaobjects:eject` and own it ([Own your codegen → Java and Kotlin](../../docs/features/own-your-codegen.md#java-and-kotlin-mvn-metaobjectseject)).
 
-- **Codegen** *(reference generators)* — Spring REST + DTO + repository-interface emit (you supply the impl) (`codegen-spring`) and a Kotlin emit pipeline on KotlinPoet (`codegen-kotlin`), both ejectable; PlantUML diagrams (`codegen-plantuml`), registered and not ejectable yet; and the deprecated Mustache template engine (`codegen-mustache`), which is not ejectable and will not be. Output is hand-edit-preserving via three-way merge.
+- **Codegen** *(reference generators)* — Spring REST + DTO + repository-interface emit (you supply the impl) (`codegen-spring`) and a Kotlin emit pipeline on KotlinPoet (`codegen-kotlin`), both ejectable; PlantUML diagrams (`codegen-plantuml`), ejectable; and the deprecated Mustache template engine (`codegen-mustache`), which is not ejectable and will not be. Output is hand-edit-preserving via three-way merge.
 - **Runtime metadata** — OMDB persistence layer over modernized JDBC with Spring-`@Transactional` integration. FR-003 fully shipped: binding registry, typed jsonb codec, source/origin metamodel, atomic mapping cache + JDBC codec registry + `inTransaction` template (Plan 4). Schema migrations are owned by the TypeScript toolchain (`@metaobjectsdev/cli migrate`); the `metaobjects:migrate` Maven goal was removed. Per the schema-authority consolidation the dev/test runtime auto-create path and `MetaClassDBValidatorService` were also removed — OMDB is now pure data-access (CRUD/query/codec/transactions only).
 - **Drift detection** — Template-drift: `Renderer.verify` checks `{{...}}` references against the payload VO at build time. The live-DB-schema mode of `metaobjects:verify` was removed; the goal now covers codegen drift (`mode=codegen`, the default) and template/prompt drift (`mode=templates`).
 - **Prompt construction** — `metaobjects-render` (Mustache + payload-VO + verify), FR-006 `template.output` parser-on-receipt codegen, render output byte-identical with the other four ports against the shared render-conformance corpus.
@@ -42,7 +42,7 @@ All published to Maven Central under `com.metaobjects:*` at `8.0.0`:
 | `metaobjects-omdb-ktx` | Kotlin facade over OMDB |
 | `metaobjects-core-spring` | Spring auto-configuration + `MetaDataService` |
 | `metaobjects-spring-boot-starter` | Spring Boot starter — OMDB autoconfiguration |
-| `metaobjects-maven-plugin` | `mvn metaobjects:generate` / `:verify` (codegen + template drift) / `:editor` / `:docs` |
+| `metaobjects-maven-plugin` | `mvn metaobjects:generate` (codegen + docs generators) / `:verify` (codegen + template drift) / `:editor` / `:eject` |
 
 The `archetype` and `examples` directories were removed in 7.1.0 (they had been out of the reactor since 7.0.0 and were not deployed to Central).
 
diff --git a/server/java/codegen-base/pom.xml b/server/java/codegen-base/pom.xml
index 7d585377d..2e300e314 100644
--- a/server/java/codegen-base/pom.xml
+++ b/server/java/codegen-base/pom.xml
@@ -99,8 +99,9 @@
                  Copied at BUILD TIME from the src/main/java files the compiler just compiled,
                  so the resource IS the source: one file, one owner, nothing to drift.
 
-                 These are "entity" (JavaObjectCodeGenerator) and "extractor"
-                 (ExtractorCodeGenerator), and the rest of their emit, which eject copies
+                 These are "entity" (JavaObjectCodeGenerator), "extractor"
+                 (ExtractorCodeGenerator), "html-docs", "ai-docs" and "json-schema", and the rest
+                 of their emit, which eject copies
                  with them into the same owned package (GeneratorInfo.ejectWith(), ADR-0034
                  Amendment 6): the generator bases and the writers that emit the class body
                  for "entity", and the writer "extractor" reads its names from. "template"
@@ -137,6 +138,29 @@
                                         <include>BaseObjectCodeWriter.java</include>
                                     </includes>
                                 </resource>
+                                <!-- "html-docs", "ai-docs" and "json-schema": each a generator and
+                                     the writer that emits its file. -->
+                                <resource>
+                                    <directory>src/main/java/com/metaobjects/generator/direct/metadata/html</directory>
+                                    <includes>
+                                        <include>MetaDataHtmlDocumentationGenerator.java</include>
+                                        <include>MetaDataHtmlDocumentationWriter.java</include>
+                                    </includes>
+                                </resource>
+                                <resource>
+                                    <directory>src/main/java/com/metaobjects/generator/direct/metadata/ai</directory>
+                                    <includes>
+                                        <include>MetaDataAIDocumentationGenerator.java</include>
+                                        <include>MetaDataAIDocumentationWriter.java</include>
+                                    </includes>
+                                </resource>
+                                <resource>
+                                    <directory>src/main/java/com/metaobjects/generator/direct/metadata/file/json</directory>
+                                    <includes>
+                                        <include>MetaDataFileJsonSchemaGenerator.java</include>
+                                        <include>MetaDataFileSchemaWriter.java</include>
+                                    </includes>
+                                </resource>
                             </resources>
                         </configuration>
                     </execution>
diff --git a/server/java/codegen-base/src/main/java/com/metaobjects/generator/CodeGenMetaDataProvider.java b/server/java/codegen-base/src/main/java/com/metaobjects/generator/CodeGenMetaDataProvider.java
index 33677a0d0..c8dd412a4 100644
--- a/server/java/codegen-base/src/main/java/com/metaobjects/generator/CodeGenMetaDataProvider.java
+++ b/server/java/codegen-base/src/main/java/com/metaobjects/generator/CodeGenMetaDataProvider.java
@@ -1,16 +1,16 @@
 package com.metaobjects.generator;
 
-import com.metaobjects.generator.direct.metadata.file.json.MetaDataFileJsonSchemaGenerator;
-import com.metaobjects.generator.direct.metadata.ai.MetaDataAIDocumentationGenerator;
 import com.metaobjects.registry.MetaDataRegistry;
 import com.metaobjects.registry.MetaDataTypeProvider;
 
 /**
  * Code Generation MetaData provider that registers type extensions for code generation.
  *
- * <p>This provider delegates to existing generator classes that contain the actual extension logic
- * and constants. It supports JSON Schema generation and AI documentation generation by extending
- * existing MetaData types with generation-specific attributes.</p>
+ * <p>This provider holds the extension logic and constants itself, not the generators it serves,
+ * so a generator copied out with {@code mvn metaobjects:eject} owns emit code only: the attributes
+ * a loaded model may carry are metamodel vocabulary and stay with the loader. It supports JSON
+ * Schema generation and AI documentation generation by extending existing MetaData types with
+ * generation-specific attributes.</p>
  *
  * <h3>Generators Supported:</h3>
  * <ul>
@@ -28,13 +28,104 @@ public class CodeGenMetaDataProvider implements MetaDataTypeProvider {
 
     @Override
     public void registerTypes(MetaDataRegistry registry) {
-        // Delegate to existing generator classes that contain the extension logic and constants
-
         // Register JSON Schema generation type extensions
-        MetaDataFileJsonSchemaGenerator.registerJsonSchemaAttributes(registry);
+        registerJsonSchemaAttributes(registry);
 
         // Register AI Documentation generation type extensions
-        MetaDataAIDocumentationGenerator.registerAIDocAttributes(registry);
+        registerAIDocAttributes(registry);
+    }
+
+    // JSON Schema generation attribute constants
+    public static final String JSON_SCHEMA_VERSION = "jsonSchemaVersion";
+    public static final String JSON_SCHEMA_ID = "jsonSchemaId";
+    public static final String JSON_TITLE = "jsonTitle";
+    public static final String JSON_DESCRIPTION = "jsonDescription";
+    public static final String JSON_FORMAT = "jsonFormat";
+    public static final String JSON_PATTERN = "jsonPattern";
+    public static final String JSON_ENUM = "jsonEnum";
+    public static final String JSON_MINIMUM = "jsonMinimum";
+    public static final String JSON_MAXIMUM = "jsonMaximum";
+
+    // AI Documentation generation attribute constants
+    public static final String AI_VERSION = "aiVersion";
+    public static final String AI_DESCRIPTION = "aiDescription";
+    public static final String AI_BUSINESS_RULE = "aiBusinessRule";
+    public static final String AI_USAGE_CONTEXT = "aiUsageContext";
+    public static final String AI_VALIDATION_RULES = "aiValidationRules";
+    public static final String AI_EXAMPLES = "aiExamples";
+    public static final String AI_CONSTRAINTS = "aiConstraints";
+    public static final String AI_EXTENSION_GUIDANCE = "aiExtensionGuidance";
+    public static final String AI_CROSS_LANGUAGE_INFO = "aiCrossLanguageInfo";
+
+    /**
+     * Registers JSON Schema generation attributes for use by the service provider pattern.
+     * Called by {@link #registerTypes} to extend existing MetaData types with JSON Schema-specific attributes.
+     */
+    public static void registerJsonSchemaAttributes(MetaDataRegistry registry) {
+        // Object-level JSON Schema attributes
+        registry.findType("object", "base")
+            .optionalAttribute(JSON_SCHEMA_VERSION, "string")
+            .optionalAttribute(JSON_SCHEMA_ID, "string")
+            .optionalAttribute(JSON_TITLE, "string")
+            .optionalAttribute(JSON_DESCRIPTION, "string")
+            // Codegen object-level flags (template conditionals). Formerly registered on
+            // object.pojo; moved to object.base so the entity/value subtypes inherit them
+            // after the pojo/proxy/map subtype registrations were retired (ADR-0005).
+            .optionalAttribute("hasAuditing", "boolean")
+            .optionalAttribute("hasJpa", "boolean")
+            .optionalAttribute("hasValidation", "boolean");
+
+        // Field-level JSON Schema attributes
+        registry.findType("field", "base")
+            .optionalAttribute(JSON_TITLE, "string")
+            .optionalAttribute(JSON_DESCRIPTION, "string")
+            .optionalAttribute(JSON_FORMAT, "string")
+            .optionalAttribute(JSON_PATTERN, "string")
+            .optionalAttribute(JSON_ENUM, "string");
+
+        registry.findType("field", "string")
+            .optionalAttribute(JSON_PATTERN, "string")
+            .optionalAttribute(JSON_FORMAT, "string");
+
+        registry.findType("field", "int")
+            .optionalAttribute(JSON_MINIMUM, "int")
+            .optionalAttribute(JSON_MAXIMUM, "int");
+
+        registry.findType("field", "long")
+            .optionalAttribute(JSON_MINIMUM, "long")
+            .optionalAttribute(JSON_MAXIMUM, "long");
+    }
+
+    /**
+     * Registers AI Documentation generation attributes for use by the service provider pattern.
+     * Called by {@link #registerTypes} to extend existing MetaData types with AI documentation-specific attributes.
+     */
+    public static void registerAIDocAttributes(MetaDataRegistry registry) {
+        // Object-level AI Documentation attributes
+        registry.findType("object", "base")
+            .optionalAttribute(AI_VERSION, "string")
+            .optionalAttribute(AI_DESCRIPTION, "string")
+            .optionalAttribute(AI_BUSINESS_RULE, "string")
+            .optionalAttribute(AI_USAGE_CONTEXT, "string")
+            .optionalAttribute(AI_EXTENSION_GUIDANCE, "string")
+            .optionalAttribute(AI_CROSS_LANGUAGE_INFO, "string");
+
+        // Field-level AI Documentation attributes
+        registry.findType("field", "base")
+            .optionalAttribute(AI_DESCRIPTION, "string")
+            .optionalAttribute(AI_BUSINESS_RULE, "string")
+            .optionalAttribute(AI_USAGE_CONTEXT, "string")
+            .optionalAttribute(AI_VALIDATION_RULES, "string")
+            .optionalAttribute(AI_EXAMPLES, "string")
+            .optionalAttribute(AI_CONSTRAINTS, "string");
+
+        registry.findType("field", "string")
+            .optionalAttribute(AI_EXAMPLES, "string")
+            .optionalAttribute(AI_VALIDATION_RULES, "string");
+
+        registry.findType("field", "int")
+            .optionalAttribute(AI_CONSTRAINTS, "string")
+            .optionalAttribute(AI_EXAMPLES, "string");
     }
 
     @Override
diff --git a/server/java/codegen-base/src/main/java/com/metaobjects/generator/EmitsObjectExtractors.java b/server/java/codegen-base/src/main/java/com/metaobjects/generator/EmitsObjectExtractors.java
deleted file mode 100644
index fabd25c7c..000000000
--- a/server/java/codegen-base/src/main/java/com/metaobjects/generator/EmitsObjectExtractors.java
+++ /dev/null
@@ -1,52 +0,0 @@
-package com.metaobjects.generator;
-
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Marker: this generator EMITS the per-object {@code <Name>Extractor} classes, as a
- * generator of its own in the run.
- *
- * <p>The Java {@code entity} generator has always written those classes itself, beside each
- * concrete flavored class, and still does when nothing else in the run will. The marker
- * exists so a RUN can answer the question {@code entity} cannot answer alone: <em>is a
- * separate extractor generator writing these files?</em> When one is, {@code entity} leaves
- * them to it. Without that, wiring an owned extractor next to {@code entity} put two
- * emitters on one path: identical output hid the duplicate, and the first edit to the owned
- * copy failed the build as an output path collision.</p>
- *
- * <p>Same shape as {@link EmitsPhysicalNameConstants}: the Maven mojo builds the whole
- * {@link Generator} list before it runs any of it, so that is where the answer is derived.
- * Unlike {@code useNames} it is not a preference a pom can pin the other way: with a separate
- * extractor generator in the run, {@code entity} writing them too is the duplicate.</p>
- */
-public interface EmitsObjectExtractors {
-
-    /**
-     * The {@code entity} generator arg that says whether it writes the
-     * {@code <Name>Extractor} classes itself. Defaults to {@code true}, which is what it
-     * did before the extractor could be wired separately.
-     */
-    String ARG_EMIT_EXTRACTORS = "emitExtractors";
-
-    /** True iff some generator in {@code generators} emits the extractors on its own. */
-    static boolean includesExtractors(Collection<? extends Generator> generators) {
-        return generators.stream().anyMatch(g -> g instanceof EmitsObjectExtractors);
-    }
-
-    /**
-     * {@code args} with {@link #ARG_EMIT_EXTRACTORS} derived from the run's generator set.
-     *
-     * <p>It is {@code "false"} whenever a separate extractor generator is in the run,
-     * whatever {@code args} said, so each file has one emitter. Otherwise {@code args} is
-     * returned as it came, so a run without one behaves as it always has.</p>
-     */
-    static Map<String, String> deriveEmitExtractors(Map<String, String> args,
-                                                    Collection<? extends Generator> generators) {
-        if (!includesExtractors(generators)) return args;
-        Map<String, String> derived = new HashMap<>(args);
-        derived.put(ARG_EMIT_EXTRACTORS, "false");
-        return derived;
-    }
-}
diff --git a/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/ai/MetaDataAIDocumentationGenerator.java b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/ai/MetaDataAIDocumentationGenerator.java
index 32c94d019..3d99d3d76 100644
--- a/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/ai/MetaDataAIDocumentationGenerator.java
+++ b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/ai/MetaDataAIDocumentationGenerator.java
@@ -1,5 +1,6 @@
 package com.metaobjects.generator.direct.metadata.ai;
 
+import com.metaobjects.generator.CodeGenMetaDataProvider;
 import com.metaobjects.generator.direct.metadata.json.SingleJsonDirectGeneratorBase;
 import com.metaobjects.generator.direct.metadata.json.JsonDirectWriter;
 import com.metaobjects.loader.MetaDataLoader;
@@ -144,47 +145,42 @@ public String getConfigurationSummary() {
 
     ///////////////////////////////////////////////////
     // Service Provider Pattern Registration
-
-    // AI Documentation generation attribute constants
-    public static final String AI_VERSION = "aiVersion";
-    public static final String AI_DESCRIPTION = "aiDescription";
-    public static final String AI_BUSINESS_RULE = "aiBusinessRule";
-    public static final String AI_USAGE_CONTEXT = "aiUsageContext";
-    public static final String AI_VALIDATION_RULES = "aiValidationRules";
-    public static final String AI_EXAMPLES = "aiExamples";
-    public static final String AI_CONSTRAINTS = "aiConstraints";
-    public static final String AI_EXTENSION_GUIDANCE = "aiExtensionGuidance";
-    public static final String AI_CROSS_LANGUAGE_INFO = "aiCrossLanguageInfo";
-
-    /**
-     * Registers AI Documentation generation attributes for use by the service provider pattern.
-     * Called by CodeGenMetaDataProvider to extend existing MetaData types with AI documentation-specific attributes.
-     */
+    //
+    // The attributes and their registration live in CodeGenMetaDataProvider, which the loader
+    // consults, so a copy of this generator made by `mvn metaobjects:eject` owns emit code only.
+    // These names stay here for existing callers.
+
+    /** @deprecated use {@link CodeGenMetaDataProvider#AI_VERSION} */
+    @Deprecated
+    public static final String AI_VERSION = CodeGenMetaDataProvider.AI_VERSION;
+    /** @deprecated use {@link CodeGenMetaDataProvider#AI_DESCRIPTION} */
+    @Deprecated
+    public static final String AI_DESCRIPTION = CodeGenMetaDataProvider.AI_DESCRIPTION;
+    /** @deprecated use {@link CodeGenMetaDataProvider#AI_BUSINESS_RULE} */
+    @Deprecated
+    public static final String AI_BUSINESS_RULE = CodeGenMetaDataProvider.AI_BUSINESS_RULE;
+    /** @deprecated use {@link CodeGenMetaDataProvider#AI_USAGE_CONTEXT} */
+    @Deprecated
+    public static final String AI_USAGE_CONTEXT = CodeGenMetaDataProvider.AI_USAGE_CONTEXT;
+    /** @deprecated use {@link CodeGenMetaDataProvider#AI_VALIDATION_RULES} */
+    @Deprecated
+    public static final String AI_VALIDATION_RULES = CodeGenMetaDataProvider.AI_VALIDATION_RULES;
+    /** @deprecated use {@link CodeGenMetaDataProvider#AI_EXAMPLES} */
+    @Deprecated
+    public static final String AI_EXAMPLES = CodeGenMetaDataProvider.AI_EXAMPLES;
+    /** @deprecated use {@link CodeGenMetaDataProvider#AI_CONSTRAINTS} */
+    @Deprecated
+    public static final String AI_CONSTRAINTS = CodeGenMetaDataProvider.AI_CONSTRAINTS;
+    /** @deprecated use {@link CodeGenMetaDataProvider#AI_EXTENSION_GUIDANCE} */
+    @Deprecated
+    public static final String AI_EXTENSION_GUIDANCE = CodeGenMetaDataProvider.AI_EXTENSION_GUIDANCE;
+    /** @deprecated use {@link CodeGenMetaDataProvider#AI_CROSS_LANGUAGE_INFO} */
+    @Deprecated
+    public static final String AI_CROSS_LANGUAGE_INFO = CodeGenMetaDataProvider.AI_CROSS_LANGUAGE_INFO;
+
+    /** @deprecated use {@link CodeGenMetaDataProvider#registerAIDocAttributes} */
+    @Deprecated
     public static void registerAIDocAttributes(com.metaobjects.registry.MetaDataRegistry registry) {
-        // Object-level AI Documentation attributes
-        registry.findType("object", "base")
-            .optionalAttribute(AI_VERSION, "string")
-            .optionalAttribute(AI_DESCRIPTION, "string")
-            .optionalAttribute(AI_BUSINESS_RULE, "string")
-            .optionalAttribute(AI_USAGE_CONTEXT, "string")
-            .optionalAttribute(AI_EXTENSION_GUIDANCE, "string")
-            .optionalAttribute(AI_CROSS_LANGUAGE_INFO, "string");
-
-        // Field-level AI Documentation attributes
-        registry.findType("field", "base")
-            .optionalAttribute(AI_DESCRIPTION, "string")
-            .optionalAttribute(AI_BUSINESS_RULE, "string")
-            .optionalAttribute(AI_USAGE_CONTEXT, "string")
-            .optionalAttribute(AI_VALIDATION_RULES, "string")
-            .optionalAttribute(AI_EXAMPLES, "string")
-            .optionalAttribute(AI_CONSTRAINTS, "string");
-
-        registry.findType("field", "string")
-            .optionalAttribute(AI_EXAMPLES, "string")
-            .optionalAttribute(AI_VALIDATION_RULES, "string");
-
-        registry.findType("field", "int")
-            .optionalAttribute(AI_CONSTRAINTS, "string")
-            .optionalAttribute(AI_EXAMPLES, "string");
+        CodeGenMetaDataProvider.registerAIDocAttributes(registry);
     }
 }
\ No newline at end of file
diff --git a/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/file/json/MetaDataFileJsonSchemaGenerator.java b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/file/json/MetaDataFileJsonSchemaGenerator.java
index 1a0707ca1..c2ed31ec3 100644
--- a/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/file/json/MetaDataFileJsonSchemaGenerator.java
+++ b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/file/json/MetaDataFileJsonSchemaGenerator.java
@@ -1,5 +1,6 @@
 package com.metaobjects.generator.direct.metadata.file.json;
 
+import com.metaobjects.generator.CodeGenMetaDataProvider;
 import com.metaobjects.generator.GeneratorIOException;
 import com.metaobjects.generator.direct.metadata.json.SingleJsonDirectGeneratorBase;
 import com.metaobjects.generator.direct.metadata.json.JsonDirectWriter;
@@ -78,54 +79,42 @@ public String toString() {
 
     ///////////////////////////////////////////////////
     // Service Provider Pattern Registration
-
-    // JSON Schema generation attribute constants
-    public static final String JSON_SCHEMA_VERSION = "jsonSchemaVersion";
-    public static final String JSON_SCHEMA_ID = "jsonSchemaId";
-    public static final String JSON_TITLE = "jsonTitle";
-    public static final String JSON_DESCRIPTION = "jsonDescription";
-    public static final String JSON_FORMAT = "jsonFormat";
-    public static final String JSON_PATTERN = "jsonPattern";
-    public static final String JSON_ENUM = "jsonEnum";
-    public static final String JSON_MINIMUM = "jsonMinimum";
-    public static final String JSON_MAXIMUM = "jsonMaximum";
-
-    /**
-     * Registers JSON Schema generation attributes for use by the service provider pattern.
-     * Called by CodeGenMetaDataProvider to extend existing MetaData types with JSON Schema-specific attributes.
-     */
+    //
+    // The attributes and their registration live in CodeGenMetaDataProvider, which the loader
+    // consults, so a copy of this generator made by `mvn metaobjects:eject` owns emit code only.
+    // These names stay here for existing callers.
+
+    /** @deprecated use {@link CodeGenMetaDataProvider#JSON_SCHEMA_VERSION} */
+    @Deprecated
+    public static final String JSON_SCHEMA_VERSION = CodeGenMetaDataProvider.JSON_SCHEMA_VERSION;
+    /** @deprecated use {@link CodeGenMetaDataProvider#JSON_SCHEMA_ID} */
+    @Deprecated
+    public static final String JSON_SCHEMA_ID = CodeGenMetaDataProvider.JSON_SCHEMA_ID;
+    /** @deprecated use {@link CodeGenMetaDataProvider#JSON_TITLE} */
+    @Deprecated
+    public static final String JSON_TITLE = CodeGenMetaDataProvider.JSON_TITLE;
+    /** @deprecated use {@link CodeGenMetaDataProvider#JSON_DESCRIPTION} */
+    @Deprecated
+    public static final String JSON_DESCRIPTION = CodeGenMetaDataProvider.JSON_DESCRIPTION;
+    /** @deprecated use {@link CodeGenMetaDataProvider#JSON_FORMAT} */
+    @Deprecated
+    public static final String JSON_FORMAT = CodeGenMetaDataProvider.JSON_FORMAT;
+    /** @deprecated use {@link CodeGenMetaDataProvider#JSON_PATTERN} */
+    @Deprecated
+    public static final String JSON_PATTERN = CodeGenMetaDataProvider.JSON_PATTERN;
+    /** @deprecated use {@link CodeGenMetaDataProvider#JSON_ENUM} */
+    @Deprecated
+    public static final String JSON_ENUM = CodeGenMetaDataProvider.JSON_ENUM;
+    /** @deprecated use {@link CodeGenMetaDataProvider#JSON_MINIMUM} */
+    @Deprecated
+    public static final String JSON_MINIMUM = CodeGenMetaDataProvider.JSON_MINIMUM;
+    /** @deprecated use {@link CodeGenMetaDataProvider#JSON_MAXIMUM} */
+    @Deprecated
+    public static final String JSON_MAXIMUM = CodeGenMetaDataProvider.JSON_MAXIMUM;
+
+    /** @deprecated use {@link CodeGenMetaDataProvider#registerJsonSchemaAttributes} */
+    @Deprecated
     public static void registerJsonSchemaAttributes(com.metaobjects.registry.MetaDataRegistry registry) {
-        // Object-level JSON Schema attributes
-        registry.findType("object", "base")
-            .optionalAttribute(JSON_SCHEMA_VERSION, "string")
-            .optionalAttribute(JSON_SCHEMA_ID, "string")
-            .optionalAttribute(JSON_TITLE, "string")
-            .optionalAttribute(JSON_DESCRIPTION, "string")
-            // Codegen object-level flags (template conditionals). Formerly registered on
-            // object.pojo; moved to object.base so the entity/value subtypes inherit them
-            // after the pojo/proxy/map subtype registrations were retired (ADR-0005).
-            .optionalAttribute("hasAuditing", "boolean")
-            .optionalAttribute("hasJpa", "boolean")
-            .optionalAttribute("hasValidation", "boolean");
-
-        // Field-level JSON Schema attributes
-        registry.findType("field", "base")
-            .optionalAttribute(JSON_TITLE, "string")
-            .optionalAttribute(JSON_DESCRIPTION, "string")
-            .optionalAttribute(JSON_FORMAT, "string")
-            .optionalAttribute(JSON_PATTERN, "string")
-            .optionalAttribute(JSON_ENUM, "string");
-
-        registry.findType("field", "string")
-            .optionalAttribute(JSON_PATTERN, "string")
-            .optionalAttribute(JSON_FORMAT, "string");
-
-        registry.findType("field", "int")
-            .optionalAttribute(JSON_MINIMUM, "int")
-            .optionalAttribute(JSON_MAXIMUM, "int");
-
-        registry.findType("field", "long")
-            .optionalAttribute(JSON_MINIMUM, "long")
-            .optionalAttribute(JSON_MAXIMUM, "long");
+        CodeGenMetaDataProvider.registerJsonSchemaAttributes(registry);
     }
 }
\ No newline at end of file
diff --git a/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/html/HtmlDirectWriter.java b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/html/HtmlDirectWriter.java
new file mode 100644
index 000000000..0db4cc8a4
--- /dev/null
+++ b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/html/HtmlDirectWriter.java
@@ -0,0 +1,21 @@
+package com.metaobjects.generator.direct.metadata.html;
+
+import com.metaobjects.generator.GeneratorIOException;
+import com.metaobjects.generator.GeneratorIOWriter;
+import com.metaobjects.loader.MetaDataLoader;
+
+/**
+ * Base class for HTML direct writers: what {@link SingleHtmlDirectGeneratorBase} drives. This is
+ * the HTML equivalent of {@code JsonDirectWriter}. The base names this type and not a writer
+ * that emits a particular page, so a generator copied out with {@code mvn metaobjects:eject}
+ * pairs with the copy of its own writer.
+ */
+public abstract class HtmlDirectWriter<T extends HtmlDirectWriter> extends GeneratorIOWriter<T> {
+
+    public HtmlDirectWriter(MetaDataLoader loader) throws GeneratorIOException {
+        super(loader);
+    }
+
+    /** Write the whole page to the stream the writer was given. */
+    public abstract void writeHtml() throws GeneratorIOException;
+}
diff --git a/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/html/MetaDataHtmlDocumentationGenerator.java b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/html/MetaDataHtmlDocumentationGenerator.java
index 795850c3f..f04415096 100644
--- a/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/html/MetaDataHtmlDocumentationGenerator.java
+++ b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/html/MetaDataHtmlDocumentationGenerator.java
@@ -1,5 +1,9 @@
 package com.metaobjects.generator.direct.metadata.html;
 
+// Eject note (ADR-0034 Amendment 8): `mvn metaobjects:eject` copies this file with its writer. The
+// base class stays in com.metaobjects.generator.direct.metadata.html as engine, so it is imported by
+// name — a bare same-package reference would not resolve from the copy.
+import com.metaobjects.generator.direct.metadata.html.SingleHtmlDirectGeneratorBase;
 import com.metaobjects.generator.GeneratorIOException;
 import com.metaobjects.loader.MetaDataLoader;
 import org.slf4j.Logger;
diff --git a/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/html/MetaDataHtmlDocumentationWriter.java b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/html/MetaDataHtmlDocumentationWriter.java
index 63a18877c..e8c4a8011 100644
--- a/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/html/MetaDataHtmlDocumentationWriter.java
+++ b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/html/MetaDataHtmlDocumentationWriter.java
@@ -1,6 +1,7 @@
 package com.metaobjects.generator.direct.metadata.html;
 
-import com.metaobjects.generator.GeneratorIOWriter;
+// Imported by name: this file is copied out by `mvn metaobjects:eject`, and the base stays in the package.
+import com.metaobjects.generator.direct.metadata.html.HtmlDirectWriter;
 import com.metaobjects.generator.GeneratorIOException;
 import com.metaobjects.loader.MetaDataLoader;
 import com.metaobjects.registry.MetaDataRegistry;
@@ -38,7 +39,7 @@
  * - Plugin and extension development
  * - Cross-team collaboration and knowledge sharing
  */
-public class MetaDataHtmlDocumentationWriter extends GeneratorIOWriter<MetaDataHtmlDocumentationWriter> {
+public class MetaDataHtmlDocumentationWriter extends HtmlDirectWriter<MetaDataHtmlDocumentationWriter> {
 
     private static final Logger log = LoggerFactory.getLogger(MetaDataHtmlDocumentationWriter.class);
 
@@ -91,6 +92,7 @@ public MetaDataHtmlDocumentationWriter withExtensionGuide(boolean includeExtensi
         return this;
     }
 
+    @Override
     public void writeHtml() throws GeneratorIOException {
         try {
             log.info("Generating professional HTML documentation for {} types",
diff --git a/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/html/SingleHtmlDirectGeneratorBase.java b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/html/SingleHtmlDirectGeneratorBase.java
index 6b74cbc81..e38dbcaaf 100644
--- a/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/html/SingleHtmlDirectGeneratorBase.java
+++ b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/html/SingleHtmlDirectGeneratorBase.java
@@ -19,7 +19,7 @@ public void execute(MetaDataLoader loader) {
 
         File outf = null;
         OutputStream fos = null;
-        MetaDataHtmlDocumentationWriter writer = null;
+        HtmlDirectWriter writer = null;
 
         parseArgs();
 
@@ -54,8 +54,25 @@ public void execute(MetaDataLoader loader) {
     ///////////////////////////////////////////////////////////////////////////////////////
     // Implementation Methods
 
-    protected abstract MetaDataHtmlDocumentationWriter getWriter(MetaDataLoader loader, OutputStream os) throws GeneratorIOException;
+    protected abstract HtmlDirectWriter getWriter(MetaDataLoader loader, OutputStream os) throws GeneratorIOException;
 
+    protected void writeHtml(HtmlDirectWriter writer) throws GeneratorIOException {
+        // A subclass written against the stock writer overrides the method below; keep calling it.
+        if (writer instanceof MetaDataHtmlDocumentationWriter) {
+            writeHtml((MetaDataHtmlDocumentationWriter) writer);
+            return;
+        }
+        log.info("Writing HTML file: " + writer.getFilename());
+        writer.writeHtml();
+    }
+
+    /**
+     * The hook as it was before the base drove {@link HtmlDirectWriter}: a subclass that overrides
+     * this keeps being called whenever its {@link #getWriter} returns the stock writer.
+     *
+     * @deprecated override {@link #writeHtml(HtmlDirectWriter)}
+     */
+    @Deprecated
     protected void writeHtml(MetaDataHtmlDocumentationWriter writer) throws GeneratorIOException {
         log.info("Writing HTML file: " + writer.getFilename());
         writer.writeHtml();
diff --git a/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/object/javacode/ExtractorCodeGenerator.java b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/object/javacode/ExtractorCodeGenerator.java
index ae3e244c5..9feb1f34f 100644
--- a/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/object/javacode/ExtractorCodeGenerator.java
+++ b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/object/javacode/ExtractorCodeGenerator.java
@@ -3,7 +3,6 @@
 // Eject note (ADR-0034 Amendment 6): `mvn metaobjects:eject -Dnames=extractor` copies this
 // file together with JavaCodeWriter and BaseObjectCodeWriter, into one package. JavaCodeWriter,
 // named bare below, is that copy: the names an owned extractor writes come from owned code.
-import com.metaobjects.generator.EmitsObjectExtractors;
 import com.metaobjects.generator.GeneratorBase;
 import com.metaobjects.generator.GeneratorException;
 import com.metaobjects.generator.direct.object.BaseObjectCodeGenerator;
@@ -46,13 +45,12 @@
  * flavored type. The {@code extractLenient(...)} overload widens through {@code ExtractionResult<?>}
  * to expose the typed {@code ExtractionResult<<Type>>}.</p>
  *
- * <p><b>Two ways to run it.</b> Wired on its own as a {@code <generator>}, {@link #execute}
- * writes one Extractor per concrete object, named by the same {@code pkgPrefix} /
- * {@code pkgSuffix} / {@code namePrefix} / {@code nameSuffix} args the {@code entity}
- * generator takes, so give both the same values. Left out of the run, the {@code entity}
- * generator ({@link JavaObjectCodeGenerator}) calls {@link #emit} itself for each concrete
- * flavored class, which is what it has always done. A run that holds both writes each file
- * once: {@link EmitsObjectExtractors} is how {@code entity} knows to leave them to this.</p>
+ * <p><b>One way to run it.</b> Wired as a {@code <generator>}, {@link #execute} writes one
+ * Extractor per concrete object, named by the same {@code pkgPrefix} / {@code pkgSuffix} /
+ * {@code namePrefix} / {@code nameSuffix} args the {@code entity} generator takes, so give
+ * both the same values. Nothing else writes them: through 8.0 the {@code entity} generator
+ * ({@link JavaObjectCodeGenerator}) wrote one beside each concrete class for a pom that did
+ * not list this generator, and ADR-0034 Amendment 9 removed that.</p>
  *
  * <p>An Extractor casts to the generated flavored class, so it needs the {@code entity}
  * generator with a concrete {@code flavor} in the same run, selecting the same objects: give
@@ -63,7 +61,7 @@
  * {@code protected} so a subclass can override one (e.g. {@link #writeExtractMethod})
  * without reimplementing the whole class.</p>
  */
-public class ExtractorCodeGenerator extends GeneratorBase implements EmitsObjectExtractors {
+public class ExtractorCodeGenerator extends GeneratorBase {
 
     /** Fully-qualified name of the runtime extract entry point (emitted as a source FQN string). */
     public static final String META_OBJECT_EXTRACT_FQN =
diff --git a/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/object/javacode/JavaObjectCodeGenerator.java b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/object/javacode/JavaObjectCodeGenerator.java
index 8dc07b625..cf7aa81d3 100644
--- a/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/object/javacode/JavaObjectCodeGenerator.java
+++ b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/object/javacode/JavaObjectCodeGenerator.java
@@ -2,12 +2,7 @@
 
 // Eject note (ADR-0034 Amendment 6): `mvn metaobjects:eject -Dnames=entity` copies this file
 // together with JavaCodeGenerator, BaseObjectCodeGenerator and the four writers, into one
-// package. The classes named bare below are those copies. ExtractorCodeGenerator is the
-// `extractor` generator and is NOT part of this copy, so it is imported by name: that is
-// what keeps the ejected copy compiling, and calling the packaged one.
-import com.metaobjects.generator.direct.object.javacode.ExtractorCodeGenerator;
-
-import com.metaobjects.generator.EmitsObjectExtractors;
+// package. The classes named bare below are those copies.
 import com.metaobjects.generator.GeneratorException;
 import com.metaobjects.generator.direct.GenerationContext;
 import com.metaobjects.generator.direct.object.BaseObjectCodeWriter;
@@ -50,8 +45,13 @@
  * {@link JavaCodeWriter}, {@link PojoAwareCodeWriter}, {@link ValueObjectCodeWriter}). This
  * file holds which flavors exist and which writer each one gets ({@link #createWriter}),
  * the {@code ObjectClassBindingProvider} source and its {@code META-INF/services}
- * registration, and whether the Extractors are written here. To change a field, a
- * constructor or an accessor, edit the writer.</p>
+ * registration. To change a field, a constructor or an accessor, edit the writer.</p>
+ *
+ * <p><b>It writes no {@code <Name>Extractor}.</b> Through 8.0 it wrote one beside every
+ * concrete class, for a pom that listed only this generator. A file no {@code <generator>}
+ * entry declares is what ADR-0034 Amendment 9 rules out, so those are written by the
+ * {@code extractor} generator ({@link ExtractorCodeGenerator}) and by nothing else: list it,
+ * with this entry's {@code outputDir}, naming args and {@code <filters>}, to get them.</p>
  */
 public class JavaObjectCodeGenerator extends JavaCodeGenerator {
 
@@ -77,16 +77,6 @@ private boolean isConcreteFlavor() {
         return FLAVOR_POJO_AWARE.equals(getFlavor()) || FLAVOR_VALUE_OBJECT.equals(getFlavor());
     }
 
-    /**
-     * Whether this generator writes the Extractors itself: the
-     * {@link EmitsObjectExtractors#ARG_EMIT_EXTRACTORS} arg, default {@code true}. The Maven
-     * plugin sets it to {@code false} when a separate {@code extractor} generator is in the
-     * same {@code <generators>} list, so each file has one emitter.
-     */
-    public boolean emitsExtractors() {
-        return Boolean.parseBoolean(getArg(EmitsObjectExtractors.ARG_EMIT_EXTRACTORS, "true"));
-    }
-
     // FQN ("pkg::Name") of the generated provider class self-registered via ServiceLoader.
     static final String PROVIDER_PACKAGE = "com.metaobjects.generated";
     static final String PROVIDER_SIMPLE_NAME = "GeneratedObjectClassBindingProvider";
@@ -128,9 +118,7 @@ protected void parseArgs() {
      * self-registering {@link ObjectClassBindingProvider} covering every generated object
      * (keyed on the package-folded metadata resolution key {@code pkg::Name}, which is what
      * {@link MetaObject#newInstance()} looks up), plus its {@code META-INF/services}
-     * registration so the provider is discoverable via {@code ServiceLoader}. It also writes
-     * a {@code <Name>Extractor} beside each concrete class, unless
-     * {@link EmitsObjectExtractors#ARG_EMIT_EXTRACTORS} says a separate extractor generator does.
+     * registration so the provider is discoverable via {@code ServiceLoader}.
      */
     @Override
     public void execute(MetaDataLoader loader) {
@@ -146,31 +134,21 @@ public void execute(MetaDataLoader loader) {
         JavaCodeWriter namer = (JavaCodeWriter)
                 createWriter(loader, null, new PrintWriter(new StringWriter()), globalContext);
         Map<String, String> fqnToClass = new LinkedHashMap<>();
-        ExtractorCodeGenerator extractorGen = emitsExtractors() ? new ExtractorCodeGenerator() : null;
         Collection<MetaObject> metadata =
                 GeneratorUtil.getFilteredMetaData(loader, getFilterClass(), getMetaDataFilters());
-        try {
-            for (MetaObject mo : metadata) {
-                // Abstract objects cannot be instantiated via newInstance(), so binding their
-                // resolution key to a generated class would make newInstance() try to construct
-                // a non-instantiable type — and an extractor for one could never produce a typed
-                // graph. Skip BOTH the binding entry and the extractor for abstract metadata
-                // (honors the abstract-codegen invariant: no instance artifacts for abstracts).
-                if (IOUtil.isAbstract(mo)) {
-                    continue;
-                }
-                String javaPkg = namer.getLanguagePackage(mo);
-                String javaClass = namer.getClassName(mo);
-                String generatedFqn = isNotBlank(javaPkg) ? javaPkg + "." + javaClass : javaClass;
-                // Key on the package-folded resolution key — NOT the dotted Java FQN.
-                fqnToClass.put(mo.getName(), generatedFqn);
-                // Emit a <Name>Extractor alongside each CONCRETE flavored class.
-                if (extractorGen != null) {
-                    extractorGen.emit(getOutputDir(), javaPkg, javaClass, mo.getName());
-                }
+        for (MetaObject mo : metadata) {
+            // Abstract objects cannot be instantiated via newInstance(), so binding their
+            // resolution key to a generated class would make newInstance() try to construct
+            // a non-instantiable type. Skip the binding entry for abstract metadata (honors
+            // the abstract-codegen invariant: no instance artifacts for abstracts).
+            if (IOUtil.isAbstract(mo)) {
+                continue;
             }
-        } catch (IOException e) {
-            throw new GeneratorException("Unable to emit generated Extractor: " + e, e);
+            String javaPkg = namer.getLanguagePackage(mo);
+            String javaClass = namer.getClassName(mo);
+            String generatedFqn = isNotBlank(javaPkg) ? javaPkg + "." + javaClass : javaClass;
+            // Key on the package-folded resolution key — NOT the dotted Java FQN.
+            fqnToClass.put(mo.getName(), generatedFqn);
         }
 
         if (fqnToClass.isEmpty()) return;
diff --git a/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/object/javacode/README-flavored-objects.md b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/object/javacode/README-flavored-objects.md
index 6124c8564..269699408 100644
--- a/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/object/javacode/README-flavored-objects.md
+++ b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/object/javacode/README-flavored-objects.md
@@ -18,18 +18,17 @@ same metadata emits any flavor.
 | `valueObject`   | `com.metaobjects.object.value.ValueObject`  | Map-backed + extensible; **perf-tuned** — each field's value-holder is bound once and accessors read/write it directly (no per-call keyed lookup). |
 | _(absent)_      | _(interface)_                               | Legacy `JavaCodeWriter` interface emission — unchanged. |
 
-For each concrete flavor, the generator also emits, per object:
-- a self-registering `ObjectClassBindingProvider` (one per run, FQN→class) + its
-  `META-INF/services` registration, so `MetaObject.newInstance()` yields the generated
-  type for that object's FQN;
-- a `<Name>Extractor` with `static <Name> extract(MetaDataLoader, String)` (typed,
-  `orThrow`) and `static ExtractionResult<<Name>> extractLenient(MetaDataLoader, String)`
-  (never-throws), both wrapping the runtime `MetaObjectExtractor.extract`.
-
-The Extractors have a generator of their own as well, `ExtractorCodeGenerator`, wirable as
-a separate `<generator>` with the same `outputDir` and naming args. When one is in the run
-`JavaObjectCodeGenerator` leaves the files to it (`emitExtractors=false`, which the Maven
-plugin sets from the generator list; `EmitsObjectExtractors` is the marker it reads).
+For each concrete flavor, the generator also emits a self-registering
+`ObjectClassBindingProvider` (one per run, FQN→class) + its `META-INF/services`
+registration, so `MetaObject.newInstance()` yields the generated type for that object's FQN.
+
+The `<Name>Extractor` classes are written by a generator of their own,
+`ExtractorCodeGenerator`, listed as a `<generator>` with the same `outputDir`, naming args
+and `<filters>`. Each has `static <Name> extract(MetaDataLoader, String)` (typed, `orThrow`)
+and `static ExtractionResult<<Name>> extractLenient(MetaDataLoader, String)` (never-throws),
+both wrapping the runtime `MetaObjectExtractor.extract`. `JavaObjectCodeGenerator` writes
+none: through 8.0 it wrote them for a pom that listed no extractor, and a file no
+`<generator>` entry declares is what ADR-0034 Amendment 9 rules out.
 
 Abstract objects are skipped for both the binding entry and the Extractor (they cannot be
 `newInstance()`-d — honors the abstract-codegen invariant: no instance artifacts for abstracts).
@@ -41,8 +40,8 @@ The legacy direct object-codegen framework — `BaseObjectCodeGenerator`,
 (byte-unchanged). All new behavior is added by **subclassing + overriding hooks**:
 
 - `JavaObjectCodeGenerator extends JavaCodeGenerator` — overrides `createWriter` (selects
-  the writer by `flavor`) and `execute` (emits the provider + Extractor after the standard
-  multi-file loop).
+  the writer by `flavor`) and `execute` (emits the provider after the standard multi-file
+  loop).
 - `PojoAwareCodeWriter` / `ValueObjectCodeWriter` `extends JavaCodeWriter` — override
   `writeObjectHeader` (the `extends <base>` clause), `writeObjectMethods` (fields + ctor),
   `writeGetter` / `writeSetter` (concrete bodies); reuse the inherited naming/type hooks
@@ -74,14 +73,12 @@ class body by editing a writer, not by subclassing one. What a copy may still re
 this module, and so what has to keep working for it:
 
 - `MultiFileDirectGeneratorBase` and `FileDirectWriter`, which the copies extend;
-- `GenerationContext`, `GeneratorUtil`, `JavaIdentifiers` and `GeneratedFileWriter`;
-- `ExtractorCodeGenerator.emit(...)`, which an owned `entity` calls until an `extractor`
-  generator is wired beside it.
+- `GenerationContext`, `GeneratorUtil`, `JavaIdentifiers` and `GeneratedFileWriter`.
 
 Two rules keep a copy set ejectable, and `EjectedBaseGeneratorsCompileTest` fails when
 either is broken. A class in a copy set may name another class of this package by its bare
-name only if that class is in the same set; anything else (the owned `entity` naming
-`ExtractorCodeGenerator`) is imported explicitly. And a copied class calls nothing that is
+name only if that class is in the same set; anything else (the owned `extractor` naming
+`BaseObjectCodeGenerator`) is imported explicitly. And a copied class calls nothing that is
 not `public` on a class left behind. A new class the writers come to depend on is added to
 the set in three places: this module's pom, `GeneratorRegistry`, and that test.
 
diff --git a/server/java/codegen-base/src/main/java/com/metaobjects/generator/util/GeneratedFileWriter.java b/server/java/codegen-base/src/main/java/com/metaobjects/generator/util/GeneratedFileWriter.java
index efef2cd16..8d77cc454 100644
--- a/server/java/codegen-base/src/main/java/com/metaobjects/generator/util/GeneratedFileWriter.java
+++ b/server/java/codegen-base/src/main/java/com/metaobjects/generator/util/GeneratedFileWriter.java
@@ -46,7 +46,7 @@
  * break them silently rather than loudly:
  *
  * <ul>
- *   <li>{@code DocsMojo}'s API pages — rendered from {@code templates/api/*.mustache},
+ *   <li>The {@code api-docs} generators' pages — rendered from {@code templates/api/*.mustache},
  *       which emit no marker and are under no obligation to.</li>
  *   <li>{@code TemplateScopeGenerator} — emits whatever a user's {@code --template-spec}
  *       renders (SQL, markdown, CSV); the content is not ours to require a marker of.</li>
diff --git a/server/java/codegen-base/src/test/java/com/metaobjects/generator/direct/metadata/html/SingleHtmlBaseHookCompatTest.java b/server/java/codegen-base/src/test/java/com/metaobjects/generator/direct/metadata/html/SingleHtmlBaseHookCompatTest.java
new file mode 100644
index 000000000..774ac3500
--- /dev/null
+++ b/server/java/codegen-base/src/test/java/com/metaobjects/generator/direct/metadata/html/SingleHtmlBaseHookCompatTest.java
@@ -0,0 +1,60 @@
+package com.metaobjects.generator.direct.metadata.html;
+
+import com.metaobjects.generator.GeneratorIOException;
+import com.metaobjects.generator.GeneratorTestBase;
+import com.metaobjects.loader.MetaDataLoader;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import java.io.OutputStream;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * A subclass written before the base drove {@link HtmlDirectWriter} overrode
+ * {@code writeHtml(MetaDataHtmlDocumentationWriter)}. It has to keep being called.
+ */
+public class SingleHtmlBaseHookCompatTest extends GeneratorTestBase {
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    /** The shape of a pre-1.1 subclass: stock writer in both signatures. */
+    @SuppressWarnings("deprecation")
+    static final class OldStyleGenerator extends SingleHtmlDirectGeneratorBase {
+        int hookCalls;
+
+        @Override
+        protected MetaDataHtmlDocumentationWriter getWriter(MetaDataLoader loader, OutputStream os)
+                throws GeneratorIOException {
+            return new MetaDataHtmlDocumentationWriter(loader, os);
+        }
+
+        @Override
+        protected void writeHtml(MetaDataHtmlDocumentationWriter writer) throws GeneratorIOException {
+            hookCalls++;
+            writer.writeHtml();
+        }
+    }
+
+    @Test
+    public void anOverrideOfTheOldHookIsStillCalled() throws Exception {
+        OldStyleGenerator generator = new OldStyleGenerator();
+        Map<String, String> args = new HashMap<>();
+        args.put("outputDir", tmp.getRoot().getAbsolutePath());
+        args.put("outputFilename", "old.html");
+        generator.setArgs(args);
+        MetaDataLoader loader = new MetaDataLoader(com.metaobjects.loader.LoaderOptions.create(false, false, true),
+                MetaDataLoader.SUBTYPE_MANUAL, "htmlHookCompat");
+        loader.init();
+
+        generator.execute(loader);
+
+        assertEquals("the old hook ran once", 1, generator.hookCalls);
+        assertTrue(new java.io.File(tmp.getRoot(), "old.html").length() > 0);
+    }
+}
diff --git a/server/java/codegen-base/src/test/java/com/metaobjects/generator/direct/object/JavaCodegenWriteGuardTest.java b/server/java/codegen-base/src/test/java/com/metaobjects/generator/direct/object/JavaCodegenWriteGuardTest.java
index f65355b25..0a846cb41 100644
--- a/server/java/codegen-base/src/test/java/com/metaobjects/generator/direct/object/JavaCodegenWriteGuardTest.java
+++ b/server/java/codegen-base/src/test/java/com/metaobjects/generator/direct/object/JavaCodegenWriteGuardTest.java
@@ -37,7 +37,7 @@
  *
  * <p>Deliberately NOT covered here, because they cannot carry a marker and guarding them
  * would freeze them after the first run: the {@code META-INF/services} registration (its
- * whole content is a provider FQN), {@code TemplateScopeGenerator}, {@code DocsMojo}, and
+ * whole content is a provider FQN), {@code TemplateScopeGenerator}, the {@code api-docs} generators, and
  * {@code MustacheTemplateGenerator}. See {@code GeneratedFileWriter}'s class javadoc.
  */
 public class JavaCodegenWriteGuardTest {
diff --git a/server/java/codegen-base/src/test/java/com/metaobjects/generator/direct/object/StandaloneExtractorGeneratorTest.java b/server/java/codegen-base/src/test/java/com/metaobjects/generator/direct/object/StandaloneExtractorGeneratorTest.java
index 8a8ab7696..6feae1c2c 100644
--- a/server/java/codegen-base/src/test/java/com/metaobjects/generator/direct/object/StandaloneExtractorGeneratorTest.java
+++ b/server/java/codegen-base/src/test/java/com/metaobjects/generator/direct/object/StandaloneExtractorGeneratorTest.java
@@ -1,6 +1,5 @@
 package com.metaobjects.generator.direct.object;
 
-import com.metaobjects.generator.EmitsObjectExtractors;
 import com.metaobjects.generator.Generator;
 import com.metaobjects.generator.GeneratorException;
 import com.metaobjects.generator.direct.object.javacode.ExtractorCodeGenerator;
@@ -30,13 +29,13 @@
 import static org.junit.Assert.fail;
 
 /**
- * The {@code extractor} generator wired on its own.
+ * The {@code extractor} generator: the one thing that writes a {@code <Name>Extractor}.
  *
- * <p>It used to exist only as a step inside {@code entity}: no {@code <generator>} entry
- * could name it, so it could not be owned or drift-checked apart from {@code entity}. These
- * tests hold the three things that make it a generator in its own right: it writes the same
- * files {@code entity} writes, {@code entity} can be told to leave them to it, and with
- * nothing told, {@code entity} still writes them as it always has.</p>
+ * <p>Through 8.0 the files were a step inside {@code entity}, written for a pom that declared
+ * no such thing. ADR-0034 Amendment 9 rules out output no {@code <generator>} entry declares,
+ * so these tests hold both halves: {@code entity} writes none, and this generator writes one
+ * per concrete object {@code entity} wrote a class for, named by {@code entity}'s naming args
+ * and narrowed by its filters.</p>
  */
 public class StandaloneExtractorGeneratorTest {
 
@@ -103,46 +102,57 @@ private static Map<String, String> extractors(Path root) throws IOException {
         return out;
     }
 
-    @Test
-    public void entityStillWritesTheExtractorsWhenNothingElseDoes() throws Exception {
-        Path out = tmp.newFolder("fused").toPath();
-        run(new JavaObjectCodeGenerator(), entityArgs(out, "pojoAware"), loadMeta());
-
-        assertEquals(List.of("acme/shapes/CircleExtractor.java", "acme/shapes/DrawingExtractor.java"),
-                List.copyOf(extractors(out).keySet()));
+    /** {@code entity} and {@code extractor} over one output directory, as a pom lists them. */
+    private Path entityAndExtractor(String dir, String flavor, Map<String, String> naming, List<String> filters)
+            throws Exception {
+        Path out = tmp.newFolder(dir).toPath();
+        JavaObjectCodeGenerator entity = new JavaObjectCodeGenerator();
+        ExtractorCodeGenerator extractor = new ExtractorCodeGenerator();
+        entity.setFilters(filters);
+        extractor.setFilters(filters);
+        Map<String, String> entityArgs = entityArgs(out, flavor);
+        entityArgs.putAll(naming);
+        Map<String, String> extractorArgs = new HashMap<>(naming);
+        extractorArgs.put("outputDir", out.toString());
+        MetaDataLoader loader = loadMeta();
+        run(entity, entityArgs, loader);
+        run(extractor, extractorArgs, loader);
+        return out;
     }
 
     @Test
-    public void entityLeavesTheExtractorsAloneWhenToldASeparateGeneratorWritesThem() throws Exception {
-        Path out = tmp.newFolder("split").toPath();
-        Map<String, String> args = entityArgs(out, "pojoAware");
-        args.put(EmitsObjectExtractors.ARG_EMIT_EXTRACTORS, "false");
-        run(new JavaObjectCodeGenerator(), args, loadMeta());
-
-        assertTrue("entity wrote extractors it was told to leave: " + extractors(out).keySet(),
-                extractors(out).isEmpty());
-        // The rest of entity's output is untouched by the arg.
-        assertTrue(Files.exists(out.resolve("acme/shapes/Circle.java")));
-        assertTrue(Files.exists(out.resolve(
-                "com/metaobjects/generated/GeneratedObjectClassBindingProvider.java")));
+    public void entityWritesNoExtractorInEitherConcreteFlavor() throws Exception {
+        for (String flavor : List.of("pojoAware", "valueObject")) {
+            Path out = tmp.newFolder("entity-" + flavor).toPath();
+            run(new JavaObjectCodeGenerator(), entityArgs(out, flavor), loadMeta());
+            ObjectClassRegistry.resetGlobal();
+
+            assertTrue(flavor + ": entity wrote an extractor no <generator> entry declared: "
+                    + extractors(out).keySet(), extractors(out).isEmpty());
+            // The rest of entity's output is what it was.
+            assertTrue(Files.exists(out.resolve("acme/shapes/Circle.java")));
+            assertTrue(Files.exists(out.resolve(
+                    "com/metaobjects/generated/GeneratedObjectClassBindingProvider.java")));
+        }
     }
 
     @Test
-    public void onItsOwnItWritesTheSameFilesEntityWrites() throws Exception {
-        Path fused = tmp.newFolder("fused").toPath();
-        run(new JavaObjectCodeGenerator(), entityArgs(fused, "valueObject"), loadMeta());
-
-        Path standalone = tmp.newFolder("standalone").toPath();
+    public void itWritesOneExtractorPerConcreteObjectAndNothingElse() throws Exception {
+        Path out = tmp.newFolder("standalone").toPath();
         Map<String, String> args = new HashMap<>();
-        args.put("outputDir", standalone.toString());
+        args.put("outputDir", out.toString());
         run(new ExtractorCodeGenerator(), args, loadMeta());
 
-        assertFalse(extractors(fused).isEmpty());
-        assertEquals(extractors(fused), extractors(standalone));
-        // And nothing but extractors: the abstract Shape gets none, and no class is written.
-        try (Stream<Path> walk = Files.walk(standalone)) {
+        // The abstract Shape gets none, and no class is written.
+        assertEquals(List.of("acme/shapes/CircleExtractor.java", "acme/shapes/DrawingExtractor.java"),
+                List.copyOf(extractors(out).keySet()));
+        try (Stream<Path> walk = Files.walk(out)) {
             assertEquals(2, walk.filter(Files::isRegularFile).count());
         }
+        String circle = extractors(out).get("acme/shapes/CircleExtractor.java");
+        assertTrue(circle, circle.contains("package acme.shapes;"));
+        assertTrue(circle, circle.contains("public final class CircleExtractor {"));
+        assertTrue(circle, circle.contains("public static Circle extract("));
     }
 
     @Test
@@ -153,39 +163,23 @@ public void itNamesTheExtractorsByTheSameArgsEntityNamesItsClassesBy() throws Ex
         naming.put("namePrefix", "My");
         naming.put("nameSuffix", "Vo");
 
-        Path fused = tmp.newFolder("fused").toPath();
-        Map<String, String> entity = entityArgs(fused, "pojoAware");
-        entity.putAll(naming);
-        run(new JavaObjectCodeGenerator(), entity, loadMeta());
-
-        Path standalone = tmp.newFolder("standalone").toPath();
-        Map<String, String> args = new HashMap<>(naming);
-        args.put("outputDir", standalone.toString());
-        run(new ExtractorCodeGenerator(), args, loadMeta());
+        Path out = entityAndExtractor("named", "pojoAware", naming, List.of());
 
-        assertTrue(extractors(standalone).containsKey(
-                "com/example/acme/shapes/model/MyCircleVoExtractor.java"));
-        assertEquals(extractors(fused), extractors(standalone));
+        // The extractor sits beside the class entity wrote, and casts to it.
+        assertTrue(Files.exists(out.resolve("com/example/acme/shapes/model/MyCircleVo.java")));
+        String extractor = extractors(out).get("com/example/acme/shapes/model/MyCircleVoExtractor.java");
+        assertTrue("no extractor beside MyCircleVo: " + extractors(out).keySet(), extractor != null);
+        assertTrue(extractor, extractor.contains("package com.example.acme.shapes.model;"));
+        assertTrue(extractor, extractor.contains("public static MyCircleVo extract("));
     }
 
     @Test
     public void givenEntitysFiltersItWritesAnExtractorForExactlyTheClassesEntityWrites() throws Exception {
-        List<String> filters = List.of(PKG + "::Drawing");
+        Path out = entityAndExtractor("filtered", "pojoAware", Map.of(), List.of(PKG + "::Drawing"));
 
-        Path fused = tmp.newFolder("fused").toPath();
-        JavaObjectCodeGenerator entity = new JavaObjectCodeGenerator();
-        entity.setFilters(filters);
-        run(entity, entityArgs(fused, "pojoAware"), loadMeta());
-
-        Path standalone = tmp.newFolder("standalone").toPath();
-        ExtractorCodeGenerator extractor = new ExtractorCodeGenerator();
-        extractor.setFilters(filters);
-        Map<String, String> args = new HashMap<>();
-        args.put("outputDir", standalone.toString());
-        run(extractor, args, loadMeta());
-
-        assertEquals(List.of("acme/shapes/DrawingExtractor.java"), List.copyOf(extractors(standalone).keySet()));
-        assertEquals(extractors(fused), extractors(standalone));
+        assertEquals(List.of("acme/shapes/DrawingExtractor.java"), List.copyOf(extractors(out).keySet()));
+        assertTrue(Files.exists(out.resolve("acme/shapes/Drawing.java")));
+        assertFalse(Files.exists(out.resolve("acme/shapes/Circle.java")));
     }
 
     @Test
@@ -197,27 +191,4 @@ public void itRefusesToRunWithNoOutputDirectory() {
             assertTrue(e.getMessage(), e.getMessage().contains("outputDir"));
         }
     }
-
-    @Test
-    public void aRunDerivesTheArgFromTheGeneratorsInIt() {
-        Map<String, String> args = Map.of("outputDir", "out");
-
-        // No separate extractor in the run: the arg stays unset, so entity keeps its default.
-        assertFalse(EmitsObjectExtractors.deriveEmitExtractors(
-                args, List.of(new JavaObjectCodeGenerator()))
-                .containsKey(EmitsObjectExtractors.ARG_EMIT_EXTRACTORS));
-
-        // A separate extractor in the run: entity is told to leave the files to it.
-        assertEquals("false", EmitsObjectExtractors.deriveEmitExtractors(
-                args, List.of(new JavaObjectCodeGenerator(), new ExtractorCodeGenerator()))
-                .get(EmitsObjectExtractors.ARG_EMIT_EXTRACTORS));
-
-        // An explicit "true" does not bring the second emitter back: with a separate
-        // extractor in the run, entity writing them too is the duplicate.
-        Map<String, String> pinned = new HashMap<>(args);
-        pinned.put(EmitsObjectExtractors.ARG_EMIT_EXTRACTORS, "true");
-        assertEquals("false", EmitsObjectExtractors.deriveEmitExtractors(
-                pinned, List.of(new JavaObjectCodeGenerator(), new ExtractorCodeGenerator()))
-                .get(EmitsObjectExtractors.ARG_EMIT_EXTRACTORS));
-    }
 }
diff --git a/server/java/codegen-kotlin/pom.xml b/server/java/codegen-kotlin/pom.xml
index e4adc85b9..74895cc9f 100644
--- a/server/java/codegen-kotlin/pom.xml
+++ b/server/java/codegen-kotlin/pom.xml
@@ -244,6 +244,24 @@
                     <include>KotlinStoredProcGenerator.kt</include>
                     <include>KotlinValidatorGenerator.kt</include>
                     <include>KotlinRequirementTestsGenerator.kt</include>
+                    <!-- The emitters a generator above writes through, handed over with it
+                         (GeneratorInfo.ejectWith). -->
+                    <include>KotlinEnumEmitter.kt</include>
+                    <include>KotlinExtractSchemaEmitter.kt</include>
+                    <include>KotlinOutputFormatSpecEmitter.kt</include>
+                  </includes>
+                </resource>
+                <!-- "api-docs": the generator, the page IR, the builder that fills it, the renderer and
+                     the page paths. They sit in the apidocs subpackage; the owned copy lands in one
+                     package, so they ship flat beside the other sources. -->
+                <resource>
+                  <directory>src/main/kotlin/com/metaobjects/generator/kotlin/apidocs</directory>
+                  <includes>
+                    <include>KotlinApiDocsGenerator.kt</include>
+                    <include>KotlinApiModel.kt</include>
+                    <include>KotlinApiModelBuilder.kt</include>
+                    <include>KotlinApiDocsRenderer.kt</include>
+                    <include>DocsPaths.kt</include>
                   </includes>
                 </resource>
               </resources>
diff --git a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/Fr019SharedEnum.kt b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/Fr019SharedEnum.kt
index 3fdedca55..bb08d1940 100644
--- a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/Fr019SharedEnum.kt
+++ b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/Fr019SharedEnum.kt
@@ -19,6 +19,12 @@ import com.squareup.kotlinpoet.ClassName
  * per-port-configured namespace (ADR-0001 — never an FQN in metadata). The namespace binds to
  * the enum's declaring metadata package via a package→namespace map + a single fallback, both
  * generator args every generator that types an enum reads through [ProvidedEnumConfig.fromArgs].
+ *
+ * <p>This object writes no output. It answers "what is this enum called, and where does it live",
+ * and the type mapper, the generator utilities and the M:N support take its [ProvidedEnumConfig]
+ * as an argument, so it is the engine (ADR-0034 Amendment 8, ruling 2) and `mvn metaobjects:eject`
+ * leaves it in the package. The file an enum is written to is [KotlinEnumEmitter]'s, and that one
+ * is handed over with `entity`.</p>
  */
 object Fr019SharedEnum {
 
@@ -38,14 +44,14 @@ object Fr019SharedEnum {
     data class ProvidedEnumConfig(
         val fallbackNamespace: String?,
         val packageNamespaces: Map<String, String>,
-        internal val providedInDeclarationPackage: Boolean = false,
+        val providedInDeclarationPackage: Boolean = false,
     ) {
         companion object {
             /**
              * The config every deprecated helper form that takes none delegates with, so a
              * generator ejected before [fromArgs] existed keeps the answer it had then.
              */
-            internal val DECLARATION_PACKAGE: ProvidedEnumConfig =
+            val DECLARATION_PACKAGE: ProvidedEnumConfig =
                 ProvidedEnumConfig(null, emptyMap(), providedInDeclarationPackage = true)
 
             /**
diff --git a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/GeneratorRegistry.kt b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/GeneratorRegistry.kt
index 2e8431c52..bfc3c0c03 100644
--- a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/GeneratorRegistry.kt
+++ b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/GeneratorRegistry.kt
@@ -21,6 +21,11 @@ package com.metaobjects.generator.kotlin
 
 import com.metaobjects.generator.Generator
 import com.metaobjects.generator.direct.MultiFileDirectGeneratorBase
+import com.metaobjects.generator.kotlin.apidocs.DocsPaths
+import com.metaobjects.generator.kotlin.apidocs.KotlinApiDocsGenerator
+import com.metaobjects.generator.kotlin.apidocs.KotlinApiDocsRenderer
+import com.metaobjects.generator.kotlin.apidocs.KotlinApiModel
+import com.metaobjects.generator.kotlin.apidocs.KotlinApiModelBuilder
 
 /** Tier of a registered generator (ADR-0020 / ADR-0021 D1). */
 enum class GeneratorTier {
@@ -72,7 +77,7 @@ enum class GeneratorLayer {
  * at run time, never via the constructor), so calling it must NOT throw —
  * `--list` relies on that.
  */
-data class GeneratorInfo(
+data class GeneratorInfo @JvmOverloads constructor(
     /** Stable, cross-port-consistent id. Equals the registry map key. */
     val name: String,
     /** One-line (no newline) human description for `--list`. */
@@ -94,6 +99,14 @@ data class GeneratorInfo(
      * `docs/superpowers/specs/2026-09-22-eject-in-every-port-design.md` (JVM section).
      */
     val ejectResourcePath: String? = null,
+    /**
+     * Fully-qualified names of the classes that hold the rest of this generator's emit, copied
+     * by `mvn metaobjects:eject` into the same owned package as the generator: the emitters it
+     * writes through. Each is shipped as `<EJECT_RESOURCE_ROOT><SimpleName>.kt`. A class two
+     * generators share is copied once. The engine (naming, type mapping, model walks, the
+     * generator base) is not listed: it stays in the package (ADR-0034 Amendment 8).
+     */
+    val ejectWith: List<String> = emptyList(),
 )
 
 /** Classpath root every ejectable Kotlin generator's reference source is shipped under. */
@@ -102,6 +115,22 @@ const val EJECT_RESOURCE_ROOT: String = "META-INF/metaobjects/reference/kotlin/"
 /** `<EJECT_RESOURCE_ROOT>/<simple class name>.kt` for an ejectable generator. */
 private fun ejectPath(simpleClassName: String): String = EJECT_RESOURCE_ROOT + simpleClassName + ".kt"
 
+/** The enum file writer `entity` calls. */
+private val ENUM_EMIT: List<String> = listOf(KotlinEnumEmitter::class.java.name)
+
+/** The rest of `api-docs`: the page IR (one file, `KotlinApiModel.kt`, which also holds the unit, symbol, field
+ *  and kind types), the builder that fills it, the renderer and the page paths. */
+private val API_DOCS_EMIT: List<String> = listOf(
+    KotlinApiModel::class.java.name, KotlinApiModelBuilder::class.java.name,
+    KotlinApiDocsRenderer::class.java.name, DocsPaths::class.java.name,
+)
+
+/** The extraction-mirror writer `output-parser` calls, and the prompt-format-spec writer `output-prompt`
+ *  calls (which delegates its literals to the mirror writer). */
+private val PARSER_EMIT: List<String> = listOf(KotlinExtractSchemaEmitter::class.java.name)
+private val PROMPT_EMIT: List<String> =
+    listOf(KotlinOutputFormatSpecEmitter::class.java.name, KotlinExtractSchemaEmitter::class.java.name)
+
 /**
  * The stable-name generator registry. Registers every Kotlin generator that
  * exists so all are discoverable (`--list`) and (in a follow-on) selectable by
@@ -119,6 +148,7 @@ val GENERATOR_REGISTRY: Map<String, GeneratorInfo> = linkedMapOf(
         layer = GeneratorLayer.MODEL,
         factory = ::KotlinEntityGenerator,
         ejectResourcePath = ejectPath("KotlinEntityGenerator"),
+        ejectWith = ENUM_EMIT,
     ),
     "routes" to GeneratorInfo(
         name = "routes",
@@ -147,6 +177,7 @@ val GENERATOR_REGISTRY: Map<String, GeneratorInfo> = linkedMapOf(
         layer = GeneratorLayer.CAPABILITY,
         factory = ::KotlinOutputParserGenerator,
         ejectResourcePath = ejectPath("KotlinOutputParserGenerator"),
+        ejectWith = PARSER_EMIT,
     ),
     "output-prompt" to GeneratorInfo(
         name = "output-prompt",
@@ -155,6 +186,7 @@ val GENERATOR_REGISTRY: Map<String, GeneratorInfo> = linkedMapOf(
         layer = GeneratorLayer.CAPABILITY,
         factory = ::KotlinOutputPromptGenerator,
         ejectResourcePath = ejectPath("KotlinOutputPromptGenerator"),
+        ejectWith = PROMPT_EMIT,
     ),
     "render-helper" to GeneratorInfo(
         name = "render-helper",
@@ -229,6 +261,15 @@ val GENERATOR_REGISTRY: Map<String, GeneratorInfo> = linkedMapOf(
         factory = ::KotlinValidatorGenerator,
         ejectResourcePath = ejectPath("KotlinValidatorGenerator"),
     ),
+    "api-docs" to GeneratorInfo(
+        name = "api-docs",
+        description = "Per-entity/template SDK API reference (generated-code API; human + agent forms).",
+        tier = GeneratorTier.NATIVE,
+        layer = GeneratorLayer.DOCS,
+        factory = ::KotlinApiDocsGenerator,
+        ejectResourcePath = ejectPath("KotlinApiDocsGenerator"),
+        ejectWith = API_DOCS_EMIT,
+    ),
     "requirement-tests" to GeneratorInfo(
         name = "requirement-tests",
         description = "Per-package JUnit Jupiter tests, one per declared requirement, each calling a " +
diff --git a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinEnumEmitter.kt b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinEnumEmitter.kt
index cc488b3c5..66dd8fd1e 100644
--- a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinEnumEmitter.kt
+++ b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinEnumEmitter.kt
@@ -1,5 +1,12 @@
 package com.metaobjects.generator.kotlin
 
+// Eject note (ADR-0034 Amendment 8): `mvn metaobjects:eject` copies this file with the generator
+// that calls it. The engine siblings stay in com.metaobjects.generator.kotlin, so each is imported
+// by name — a bare same-package reference would not resolve from the copy.
+import com.metaobjects.generator.kotlin.Fr019SharedEnum
+import com.metaobjects.generator.kotlin.KotlinPoetFileWriter
+import com.metaobjects.generator.kotlin.KotlinTypeMapper
+
 import com.metaobjects.field.EnumField
 import com.squareup.kotlinpoet.ClassName
 import com.squareup.kotlinpoet.FileSpec
diff --git a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinExtractSchemaEmitter.kt b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinExtractSchemaEmitter.kt
index f32395a59..ed7e4e294 100644
--- a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinExtractSchemaEmitter.kt
+++ b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinExtractSchemaEmitter.kt
@@ -1,5 +1,14 @@
 package com.metaobjects.generator.kotlin
 
+// Eject note (ADR-0034 Amendment 8): `mvn metaobjects:eject` copies this file with the generator
+// that calls it. The engine siblings stay in com.metaobjects.generator.kotlin, so each is imported
+// by name — a bare same-package reference would not resolve from the copy.
+import com.metaobjects.generator.kotlin.Fr019SharedEnum
+import com.metaobjects.generator.kotlin.KotlinGenUtil
+import com.metaobjects.generator.kotlin.KotlinNaming
+import com.metaobjects.generator.kotlin.KotlinTypeMapper
+import com.metaobjects.generator.kotlin.PackageMapping
+
 import com.metaobjects.field.BooleanField
 import com.metaobjects.field.DoubleField
 import com.metaobjects.field.EnumField
diff --git a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinOutputFormatSpecEmitter.kt b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinOutputFormatSpecEmitter.kt
index 1c5ee9272..941ed6127 100644
--- a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinOutputFormatSpecEmitter.kt
+++ b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinOutputFormatSpecEmitter.kt
@@ -1,5 +1,11 @@
 package com.metaobjects.generator.kotlin
 
+// Eject note (ADR-0034 Amendment 8): `mvn metaobjects:eject` copies this file with the generator
+// that calls it. The engine siblings stay in com.metaobjects.generator.kotlin, so each is imported
+// by name — a bare same-package reference would not resolve from the copy.
+import com.metaobjects.generator.kotlin.FindInbound
+import com.metaobjects.generator.kotlin.KotlinExtractSchemaEmitter
+
 import com.metaobjects.field.EnumField
 import com.metaobjects.field.MetaField
 import com.metaobjects.field.MapField
diff --git a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/apidocs/KotlinApiDocsGenerator.kt b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/apidocs/KotlinApiDocsGenerator.kt
new file mode 100644
index 000000000..5e47f4b4e
--- /dev/null
+++ b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/apidocs/KotlinApiDocsGenerator.kt
@@ -0,0 +1,77 @@
+package com.metaobjects.generator.kotlin.apidocs
+
+// Eject note (ADR-0034 Amendment 8): `mvn metaobjects:eject -Dnames=api-docs` copies this file with the
+// api reference's IR, builder, renderer and page paths. The siblings below stay in their packages as
+// engine, so each is imported by name — a bare same-package reference would not resolve from the copy.
+import com.metaobjects.generator.FileEmittingGenerator
+import com.metaobjects.generator.FileEmittingGenerator.EmittedFile
+import com.metaobjects.generator.GeneratorException
+import com.metaobjects.generator.kotlin.Fr019SharedEnum
+import com.metaobjects.loader.MetaDataLoader
+
+/**
+ * `api-docs` — the Kotlin SDK api reference (the `api/kotlin` surface of the cross-port SDK-docs
+ * contract): one page per entity, value object, projection, served report and template, an index,
+ * and the agent-facing `AGENT-API.md`.
+ *
+ * An ordinary generator: a `<generator>` entry in the list `mvn metaobjects:generate` runs, and
+ * nothing writes these pages for a pom that does not list it (ADR-0034 Amendment 9). Its files
+ * land under `outputDir` in [ARG_API_SUBDIR]; the project label, the layout and the model
+ * back-link base are the other `<args>` below, and where a `@provided` enum is referenced from
+ * comes from the same enum args every Kotlin generator takes ([Fr019SharedEnum.ProvidedEnumConfig]).
+ * Give it an `outputDir` that holds generated files only: `mvn metaobjects:verify` compares each
+ * output directory as one tree, so a hand-written page there reads as stale.
+ */
+class KotlinApiDocsGenerator : FileEmittingGenerator() {
+
+    override fun generate(loader: MetaDataLoader): List<EmittedFile> {
+        val project = getArg(ARG_PROJECT_NAME, "project")
+        val subDir = getArg(ARG_API_SUBDIR, DEFAULT_API_SUBDIR)
+        val modelBaseUrl = if (hasArg(ARG_MODEL_BASE_URL)) getArg(ARG_MODEL_BASE_URL) else null
+        val layout = when (val value = getArg(ARG_LAYOUT, LAYOUT_FLAT)) {
+            LAYOUT_FLAT -> DocsPaths.Layout.FLAT
+            LAYOUT_PACKAGE -> DocsPaths.Layout.PACKAGE
+            // A misspelt layout would otherwise write every page somewhere its links do not point.
+            else -> throw GeneratorException(
+                "api-docs: <$ARG_LAYOUT> must be $LAYOUT_FLAT or $LAYOUT_PACKAGE (got \"$value\")")
+        }
+
+        val model = KotlinApiModelBuilder(Fr019SharedEnum.ProvidedEnumConfig.fromArgs(args)).build(loader, project)
+        val renderer = KotlinApiDocsRenderer()
+
+        val pages = mutableListOf<EmittedFile>()
+        val paths = HashSet<String>()
+        fun add(pagePath: String, content: String) {
+            if (!paths.add(pagePath)) throw GeneratorException("api-docs: duplicate api page output path: $pagePath")
+            pages.add(EmittedFile("$subDir/$pagePath", content))
+        }
+        for (unit in model.units) {
+            val pagePath = DocsPaths.docPageOutputPath(layout, unit.pkg, unit.node)
+            val modelHref = DocsPaths.modelCrossHref("$subDir/$pagePath", pagePath, modelBaseUrl)
+            add(pagePath, renderer.renderUnitPage(unit, modelHref))
+        }
+        add("README.md", renderer.renderIndex(model, layout))
+        add("AGENT-API.md", renderer.renderAgentApi(model))
+        return pages
+    }
+
+    companion object {
+        /** Arg: the label the agent page carries in its header. Default `project`. */
+        const val ARG_PROJECT_NAME: String = "projectName"
+
+        /** Arg: where under `outputDir` the pages land. Default [DEFAULT_API_SUBDIR]. */
+        const val ARG_API_SUBDIR: String = "apiSubDir"
+
+        /** Arg: the page layout, `flat` (one file per unit, the default) or `package`. */
+        const val ARG_LAYOUT: String = "layout"
+
+        /** Arg: when set, the base URL the pages' links to the model pages are written against. */
+        const val ARG_MODEL_BASE_URL: String = "modelBaseUrl"
+
+        /** The api-surface subdirectory of the cross-port docs contract. */
+        const val DEFAULT_API_SUBDIR: String = "api/kotlin"
+
+        private const val LAYOUT_FLAT = "flat"
+        private const val LAYOUT_PACKAGE = "package"
+    }
+}
diff --git a/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/codegen/kotlin/apidocs/ApiDocsCrossPortConformanceKtTest.kt b/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/codegen/kotlin/apidocs/ApiDocsCrossPortConformanceKtTest.kt
index 9f5eda4fd..110795fe1 100644
--- a/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/codegen/kotlin/apidocs/ApiDocsCrossPortConformanceKtTest.kt
+++ b/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/codegen/kotlin/apidocs/ApiDocsCrossPortConformanceKtTest.kt
@@ -27,7 +27,7 @@ import kotlin.test.assertTrue
  *
  * This loads the SAME input metadata the other ports load, builds the [KotlinApiModel] via
  * [KotlinApiModelBuilder], and for each manifest unit asserts — using the EXACT path/href math the
- * `metaobjects:docs` goal uses (computed via [DocsPaths], never re-derived here) — that:
+ * `api-docs` generator ([com.metaobjects.generator.kotlin.apidocs.KotlinApiDocsGenerator]) uses (computed via [DocsPaths], never re-derived here) — that:
  * - `apiKotlinSubDir + "/" + docPageOutputPath(PACKAGE, pkg, node)` equals the manifest `apiKotlinPath`;
  * - `modelCrossHref(apiKotlinPath, pagePath, null)` equals the manifest `apiKotlinToModel`;
  * - the rendered unit page actually carries the contract back-link
diff --git a/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/EjectContractTest.kt b/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/EjectContractTest.kt
index 6f2e298fc..fe6958c3c 100644
--- a/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/EjectContractTest.kt
+++ b/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/EjectContractTest.kt
@@ -39,7 +39,8 @@ import kotlin.test.assertTrue
  * entry that passes fails here, and so does a gap that is not listed.
  *
  * The copy is read from the shipped resource, not through the mojo: `maven-plugin` depends on
- * this module, not the reverse. The one edit eject makes to a Kotlin copy is its package line.
+ * this module, not the reverse. The two edits eject makes to a Kotlin copy are its package line and
+ * its imports of the classes copied with it, and this test makes the same two.
  */
 @OptIn(org.jetbrains.kotlin.compiler.plugin.ExperimentalCompilerApi::class)
 class EjectContractTest {
@@ -146,7 +147,10 @@ class EjectContractTest {
 
     @Test
     fun `completeness - the shipped reference sources are exactly the ones the registry names`() {
-        val named = GENERATOR_REGISTRY.values.mapNotNull { it.ejectResourcePath }.toSortedSet()
+        val named = GENERATOR_REGISTRY.values.flatMap { info ->
+            // The generator, and each class eject copies with it.
+            listOfNotNull(info.ejectResourcePath) + info.ejectWith.map { withResource(it) }
+        }.toSortedSet()
         assertEquals(named, shipped(EJECT_RESOURCE_ROOT))
     }
 
@@ -293,19 +297,41 @@ class EjectContractTest {
         private fun simpleName(info: GeneratorInfo): String =
             info.ejectResourcePath!!.substringAfterLast('/').substringBeforeLast('.')
 
+        /** The shipped resource of a class eject copies WITH a generator. */
+        private fun withResource(classname: String): String = EJECT_RESOURCE_ROOT + classname.substringAfterLast('.') + ".kt"
+
+        private fun readResource(resource: String, name: String): String =
+            EjectContractTest::class.java.classLoader.getResourceAsStream(resource)
+                ?.use { String(it.readAllBytes(), Charsets.UTF_8) }
+                ?: throw AssertionError("$name: $resource is not shipped")
+
+        /**
+         * One owned file as `mvn metaobjects:eject` writes it: the package line renamed, and every
+         * import of a class copied with the generator pointed at its copy.
+         */
+        private fun owned(reference: String, name: String, copied: List<String>): String {
+            val line = PACKAGE_LINE.find(reference) ?: throw AssertionError("$name has no package line")
+            var out = reference.replaceRange(line.range, "package $OWNED_PACKAGE")
+            for (classname in copied) {
+                out = out.replace(Regex("(?m)^import\\s+" + Regex.escape(classname) + "[ \\t]*$"),
+                    "import $OWNED_PACKAGE.${classname.substringAfterLast('.')}")
+            }
+            return out
+        }
+
         private val compiled = mutableMapOf<String, KotlinCompilation.Result>()
 
         /** The owned copy of one generator: the shipped reference source with its package line
          *  rewritten, compiled with nothing else beside it. Compiled once per generator. */
         private fun ownedCopy(name: String): KotlinCompilation.Result = compiled.getOrPut(name) {
             val info = GENERATOR_REGISTRY.getValue(name)
-            val reference = EjectContractTest::class.java.classLoader.getResourceAsStream(info.ejectResourcePath!!)
-                ?.use { String(it.readAllBytes(), Charsets.UTF_8) }
-                ?: throw AssertionError("$name: ${info.ejectResourcePath} is not shipped")
-            val line = PACKAGE_LINE.find(reference) ?: throw AssertionError("$name has no package line")
+            // The generator and what eject copies with it, and nothing else beside them.
+            val files = listOf(info.ejectResourcePath!!) + info.ejectWith.map { withResource(it) }
             val result = KotlinCompilation().apply {
-                sources = listOf(SourceFile.kotlin("${simpleName(info)}.kt",
-                    reference.replaceRange(line.range, "package $OWNED_PACKAGE")))
+                sources = files.map { resource ->
+                    SourceFile.kotlin(resource.substringAfterLast('/'),
+                        owned(readResource(resource, name), name, info.ejectWith))
+                }
                 inheritClassPath = true
                 messageOutputStream = java.io.OutputStream.nullOutputStream()
             }.compile()
diff --git a/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/EjectedGeneratorsCompileTest.kt b/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/EjectedGeneratorsCompileTest.kt
index 6b8a8ea73..010d4958b 100644
--- a/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/EjectedGeneratorsCompileTest.kt
+++ b/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/EjectedGeneratorsCompileTest.kt
@@ -27,8 +27,11 @@ import kotlin.test.assertTrue
 class EjectedGeneratorsCompileTest {
 
     /** Every reference this module ships, read off the registry so the list cannot fall behind it. */
-    private val ejectableSimpleNames = GENERATOR_REGISTRY.values.mapNotNull { it.ejectResourcePath }
-        .map { it.substringAfterLast('/').substringBeforeLast('.') }
+    private val ejectableSimpleNames = GENERATOR_REGISTRY.values.flatMap { info ->
+        // The generator, and the classes eject copies with it (an emitter, a page model).
+        listOfNotNull(info.ejectResourcePath).map { it.substringAfterLast('/').substringBeforeLast('.') } +
+            info.ejectWith.map { it.substringAfterLast('.') }
+    }.distinct()
 
     private val packageLine = Regex("(?m)^package\\s+[\\w.]+\\s*$")
 
@@ -43,9 +46,14 @@ class EjectedGeneratorsCompileTest {
         val srcDir = Path.of("src/main/kotlin/com/metaobjects/generator/kotlin")
         assertTrue(Files.isDirectory(srcDir), "expected ${srcDir.toAbsolutePath()} to exist")
 
+        // A generator may sit in a subpackage's directory (api-docs does); eject ships them all flat.
+        val byName = Files.walk(srcDir).use { walk -> walk.filter { it.toString().endsWith(".kt") }.toList() }
+            .associateBy { it.fileName.toString().removeSuffix(".kt") }
+
         val sources = ejectableSimpleNames.map { simpleName ->
-            val original = srcDir.resolve("$simpleName.kt")
-            assertTrue(Files.exists(original), "expected $original to exist")
+            val original = byName[simpleName]
+            assertTrue(original != null && Files.exists(original), "expected $simpleName.kt under $srcDir")
+            original!!
             val rewritten = rewritePackage(Files.readString(original), "com.acme.owned")
             SourceFile.kotlin("$simpleName.kt", rewritten)
         }
diff --git a/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/ReportingInertTest.kt b/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/ReportingInertTest.kt
index 69914f0ff..b7f68fa5e 100644
--- a/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/ReportingInertTest.kt
+++ b/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/ReportingInertTest.kt
@@ -111,6 +111,13 @@ class ReportingInertTest {
         return if (differing.isEmpty()) null else "$label: $differing differ once reporting nodes are declared"
     }
 
+    /**
+     * Every generator that writes code. `api-docs` writes the api reference, not code, and is
+     * held to the same inertness by [api docs gain exactly the view-backed report's page], which
+     * compares its pages unit by unit.
+     */
+    private val codeGenerators get() = GENERATOR_REGISTRY.values.filter { it.name != "api-docs" }
+
     /** What a generator may add for the with-model: one file of the view-backed report, from five generators. */
     private fun allowedFor(info: GeneratorInfo): Set<String> = setOfNotNull(STORE_TOTALS_FILES[info.name])
 
@@ -129,7 +136,7 @@ class ReportingInertTest {
     fun `only five generators emit for a report, each one file, for the view-backed one`() {
         // Every generator is compared before anything is asserted, so one red run names
         // every leak rather than the first.
-        val leaks = GENERATOR_REGISTRY.values.mapNotNull { info ->
+        val leaks = codeGenerators.mapNotNull { info ->
             sameOrLeak(info.name, emit("without", listOf(info)), emit("with", listOf(info)), allowedFor(info))
         }
         assertTrue(leaks.isEmpty(), leaks.joinToString("\n"))
@@ -155,7 +162,7 @@ class ReportingInertTest {
 
     @Test
     fun `a sourceless report appears in no generated file`() {
-        val files = emit("with", GENERATOR_REGISTRY.values.toList())
+        val files = emit("with", codeGenerators.toList())
         assertFalse(THREW in files, "the combined suite threw: ${files[THREW]}")
         for (report in SOURCELESS_REPORTS) {
             val hits = files.filter { (path, text) -> report in path || report in text }.keys
@@ -171,13 +178,13 @@ class ReportingInertTest {
         // Each is compared above on its error message alone, which proves nothing about its
         // output. Pinned by name so a generator that starts throwing cannot drop out
         // silently; the list may only shrink.
-        val threw = GENERATOR_REGISTRY.values.filter { THREW in emit("without", listOf(it)) }.map { it.name }.sorted()
+        val threw = codeGenerators.filter { THREW in emit("without", listOf(it)) }.map { it.name }.sorted()
         assertEquals(emptyList(), threw)
     }
 
     @Test
     fun `every runnable generator in one run emits the same files`() {
-        val runnable = GENERATOR_REGISTRY.values.filter { THREW !in emit("without", listOf(it)) }
+        val runnable = codeGenerators.filter { THREW !in emit("without", listOf(it)) }
         val expected = emit("without", runnable)
         assertFalse(THREW in expected, "the combined suite threw: ${expected[THREW]}")
         assertTrue(expected.size > 10, "only ${expected.size} files — the suite barely ran")
@@ -191,16 +198,21 @@ class ReportingInertTest {
      * sourceless one has none.
      */
     private fun apiDocs(variant: String): Map<String, String> {
-        val model = KotlinApiModelBuilder(com.metaobjects.generator.kotlin.Fr019SharedEnum.ProvidedEnumConfig.fromArgs(null)).build(load(variant), "shop")
-        val renderer = KotlinApiDocsRenderer()
-        val pages = TreeMap<String, String>()
-        for (unit in model.units) {
-            pages[DocsPaths.docPageOutputPath(DocsPaths.Layout.PACKAGE, unit.pkg, unit.node)] =
-                renderer.renderUnitPage(unit, null)
+        val out = Files.createTempDirectory("reporting-inert-docs-")
+        try {
+            val docs = GENERATOR_REGISTRY.getValue("api-docs").factory()
+            docs.setArgs(mapOf("outputDir" to out.toString(), "projectName" to "shop", "layout" to "package"))
+            docs.execute(load(variant))
+            val pages = TreeMap<String, String>()
+            Files.walk(out).use { s ->
+                s.filter { it.isRegularFile() }.forEach {
+                    pages[out.resolve("api/kotlin").relativize(it).toString()] = it.readText()
+                }
+            }
+            return pages
+        } finally {
+            out.toFile().deleteRecursively()
         }
-        pages["README.md"] = renderer.renderIndex(model, DocsPaths.Layout.PACKAGE)
-        pages["AGENT-API.md"] = renderer.renderAgentApi(model)
-        return pages
     }
 
     @Test
diff --git a/server/java/codegen-plantuml/pom.xml b/server/java/codegen-plantuml/pom.xml
index e068e0896..a8c093950 100644
--- a/server/java/codegen-plantuml/pom.xml
+++ b/server/java/codegen-plantuml/pom.xml
@@ -43,6 +43,36 @@
 
     <build>
         <plugins>
+            <!-- `mvn metaobjects:eject` ships the verbatim source of every ejectable generator
+                 inside the jar that owns it, as a classpath resource under
+                 META-INF/metaobjects/reference/java/ (see codegen-spring's pom for the same
+                 execution). "plantuml" is the generator and the writer that emits its file;
+                 eject copies both into one owned package. -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-resources-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <id>ship-eject-reference-source</id>
+                        <phase>generate-resources</phase>
+                        <goals>
+                            <goal>copy-resources</goal>
+                        </goals>
+                        <configuration>
+                            <outputDirectory>${project.build.outputDirectory}/META-INF/metaobjects/reference/java</outputDirectory>
+                            <resources>
+                                <resource>
+                                    <directory>src/main/java/com/metaobjects/generator/direct/plantuml</directory>
+                                    <includes>
+                                        <include>PlantUMLGenerator.java</include>
+                                        <include>PlantUMLWriter.java</include>
+                                    </includes>
+                                </resource>
+                            </resources>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
 </project>
\ No newline at end of file
diff --git a/server/java/codegen-spring/pom.xml b/server/java/codegen-spring/pom.xml
index f86a59298..b8303d80d 100644
--- a/server/java/codegen-spring/pom.xml
+++ b/server/java/codegen-spring/pom.xml
@@ -205,6 +205,50 @@
                                         <include>LlmTraceHelperGenerator.java</include>
                                         <include>SpringNamesGenerator.java</include>
                                         <include>JUnitRequirementTestsGenerator.java</include>
+                                        <!-- The emit classes a generator above calls, handed over
+                                             with it (GeneratorInfo.ejectWith()). -->
+                                        <include>Fr019SharedEnum.java</include>
+                                        <include>SpringRecordBuilder.java</include>
+                                        <include>OutputFormatSpecEmitter.java</include>
+                                    </includes>
+                                </resource>
+                                <!-- "api-docs": the generator, the page IR, the builder that fills it, the
+                                     renderer, the page paths and the template provider. -->
+                                <resource>
+                                    <directory>src/main/java/com/metaobjects/generator/apidocs</directory>
+                                    <includes>
+                                        <include>JavaApiDocsGenerator.java</include>
+                                        <include>ApiSymbol.java</include>
+                                        <include>ApiSymbolKind.java</include>
+                                        <include>ApiUnit.java</include>
+                                        <include>ClasspathTemplateProvider.java</include>
+                                        <include>DocsPaths.java</include>
+                                        <include>FieldShape.java</include>
+                                        <include>JavaApiDocsRenderer.java</include>
+                                        <include>JavaApiModel.java</include>
+                                        <include>JavaApiModelBuilder.java</include>
+                                        <include>JavaFieldShapes.java</include>
+                                        <include>UnitExample.java</include>
+                                    </includes>
+                                </resource>
+                            </resources>
+                        </configuration>
+                    </execution>
+                    <!-- The page text "api-docs" reads from the classpath. Eject copies it into the
+                         adopter's resources and points the owned template provider there. -->
+                    <execution>
+                        <id>ship-eject-template-source</id>
+                        <phase>generate-resources</phase>
+                        <goals>
+                            <goal>copy-resources</goal>
+                        </goals>
+                        <configuration>
+                            <outputDirectory>${project.build.outputDirectory}/META-INF/metaobjects/reference/java/templates/api</outputDirectory>
+                            <resources>
+                                <resource>
+                                    <directory>src/main/resources/templates/api</directory>
+                                    <includes>
+                                        <include>*.md.mustache</include>
                                     </includes>
                                 </resource>
                             </resources>
diff --git a/server/java/codegen-spring/src/main/java/com/metaobjects/generator/GeneratorRegistry.java b/server/java/codegen-spring/src/main/java/com/metaobjects/generator/GeneratorRegistry.java
index 8a9c056ac..09e23d176 100644
--- a/server/java/codegen-spring/src/main/java/com/metaobjects/generator/GeneratorRegistry.java
+++ b/server/java/codegen-spring/src/main/java/com/metaobjects/generator/GeneratorRegistry.java
@@ -1,8 +1,23 @@
 package com.metaobjects.generator;
 
+import com.metaobjects.generator.apidocs.ApiSymbol;
+import com.metaobjects.generator.apidocs.ApiSymbolKind;
+import com.metaobjects.generator.apidocs.ApiUnit;
+import com.metaobjects.generator.apidocs.ClasspathTemplateProvider;
+import com.metaobjects.generator.apidocs.DocsPaths;
+import com.metaobjects.generator.apidocs.FieldShape;
+import com.metaobjects.generator.apidocs.JavaApiDocsGenerator;
+import com.metaobjects.generator.apidocs.JavaApiDocsRenderer;
+import com.metaobjects.generator.apidocs.JavaApiModel;
+import com.metaobjects.generator.apidocs.JavaApiModelBuilder;
+import com.metaobjects.generator.apidocs.JavaFieldShapes;
+import com.metaobjects.generator.apidocs.UnitExample;
 import com.metaobjects.generator.direct.metadata.ai.MetaDataAIDocumentationGenerator;
+import com.metaobjects.generator.direct.metadata.ai.MetaDataAIDocumentationWriter;
 import com.metaobjects.generator.direct.metadata.file.json.MetaDataFileJsonSchemaGenerator;
+import com.metaobjects.generator.direct.metadata.file.json.MetaDataFileSchemaWriter;
 import com.metaobjects.generator.direct.metadata.html.MetaDataHtmlDocumentationGenerator;
+import com.metaobjects.generator.direct.metadata.html.MetaDataHtmlDocumentationWriter;
 import com.metaobjects.generator.direct.object.BaseObjectCodeGenerator;
 import com.metaobjects.generator.direct.object.BaseObjectCodeWriter;
 import com.metaobjects.generator.direct.object.javacode.ExtractorCodeGenerator;
@@ -11,14 +26,17 @@
 import com.metaobjects.generator.direct.object.javacode.JavaObjectCodeGenerator;
 import com.metaobjects.generator.direct.object.javacode.PojoAwareCodeWriter;
 import com.metaobjects.generator.direct.object.javacode.ValueObjectCodeWriter;
+import com.metaobjects.generator.spring.Fr019SharedEnum;
 import com.metaobjects.generator.spring.JUnitRequirementTestsGenerator;
 import com.metaobjects.generator.spring.LlmTraceHelperGenerator;
+import com.metaobjects.generator.spring.OutputFormatSpecEmitter;
 import com.metaobjects.generator.spring.SpringControllerGenerator;
 import com.metaobjects.generator.spring.SpringDtoGenerator;
 import com.metaobjects.generator.spring.SpringFilterAllowlistGenerator;
 import com.metaobjects.generator.spring.SpringNamesGenerator;
 import com.metaobjects.generator.spring.SpringOutputParserGenerator;
 import com.metaobjects.generator.spring.SpringOutputPromptGenerator;
+import com.metaobjects.generator.spring.SpringRecordBuilder;
 import com.metaobjects.generator.spring.SpringRenderHelperGenerator;
 import com.metaobjects.generator.spring.SpringRepositoryGenerator;
 import com.metaobjects.generator.spring.SpringValueObjectGenerator;
@@ -104,6 +122,7 @@ public static final class GeneratorInfo {
         private final List<String> ejectRuntime;
         private final String ejectNote;
         private final List<String> ejectWith;
+        private final List<String> ejectResources;
 
         public GeneratorInfo(String stableName, String classname, String description,
                              Tier tier, Layer layer) {
@@ -152,6 +171,23 @@ public GeneratorInfo(String stableName, String classname, String description,
         public GeneratorInfo(String stableName, String classname, String description,
                              Tier tier, Layer layer, String ejectResourcePath,
                              List<String> ejectRuntime, String ejectNote, List<String> ejectWith) {
+            this(stableName, classname, description, tier, layer, ejectResourcePath,
+                    ejectRuntime, ejectNote, ejectWith, List.of());
+        }
+
+        /**
+         * @param ejectResources the template references this GENERATOR's emit reads from the
+         *      classpath, each the path under {@link #TEMPLATE_RESOURCE_PREFIX} without its
+         *      {@code .md.mustache} extension (e.g. {@code api/index}). {@code mvn
+         *      metaobjects:eject} copies each into the adopter's module, under the owned
+         *      package's path, and points the owned template provider there, so the page text
+         *      is the adopter's too. Each is shipped at {@link #EJECT_TEMPLATE_RESOURCE_ROOT}.
+         */
+        public GeneratorInfo(String stableName, String classname, String description,
+                             Tier tier, Layer layer, String ejectResourcePath,
+                             List<String> ejectRuntime, String ejectNote, List<String> ejectWith,
+                             List<String> ejectResources) {
+            this.ejectResources = List.copyOf(ejectResources);
             this.stableName = stableName;
             this.classname = classname;
             this.description = description;
@@ -212,6 +248,12 @@ public List<String> ejectWith() {
             return ejectWith;
         }
 
+        /** Template references copied with this generator into the adopter's resources (see
+         *  the constructor). */
+        public List<String> ejectResources() {
+            return ejectResources;
+        }
+
         @Override
         public String toString() {
             return "GeneratorInfo{" + stableName + " -> " + classname
@@ -237,11 +279,35 @@ public String toString() {
             BaseObjectCodeWriter.class.getName(), JavaCodeWriter.class.getName(),
             PojoAwareCodeWriter.class.getName(), ValueObjectCodeWriter.class.getName());
 
+    /** The shared and externally-provided enum writer, and the builder a generated record
+     *  carries: emit code the DTO and value-object generators each call, so each takes a copy. */
+    private static final List<String> RECORD_EMIT = List.of(
+            Fr019SharedEnum.class.getName(), SpringRecordBuilder.class.getName());
+
+    /** The enum writer the output parser calls. */
+    private static final List<String> ENUM_EMIT = List.of(Fr019SharedEnum.class.getName());
+
+    /** The rest of {@code api-docs}: the page IR, the builder that fills it, the renderer, the page
+     *  paths and the template provider. {@code GeneratorApplicability} is the engine. */
+    private static final List<String> API_DOCS_EMIT = List.of(
+            ApiSymbol.class.getName(), ApiSymbolKind.class.getName(), ApiUnit.class.getName(),
+            ClasspathTemplateProvider.class.getName(), DocsPaths.class.getName(), FieldShape.class.getName(),
+            JavaApiDocsRenderer.class.getName(), JavaApiModel.class.getName(),
+            JavaApiModelBuilder.class.getName(), JavaFieldShapes.class.getName(), UnitExample.class.getName());
+
+    /** The page text of {@code api-docs}, read from the classpath. */
+    private static final List<String> API_DOCS_TEMPLATES = List.of("api/entity-api", "api/index", "api/agent-api");
+
+    /** The prompt-tier writer behind {@code output-prompt}: the format-spec literal. */
+    private static final List<String> PROMPT_EMIT = List.of(OutputFormatSpecEmitter.class.getName());
+
     /** The two generators that live in modules this one does not depend on
      *  ({@code codegen-plantuml}, {@code codegen-mustache}), so they are named, not
      *  referenced. {@code GeneratorRegistryConformanceTest} loads every registered class. */
     private static final String PLANTUML_GENERATOR =
             "com.metaobjects.generator.direct.plantuml.PlantUMLGenerator";
+    private static final String PLANTUML_WRITER =
+            "com.metaobjects.generator.direct.plantuml.PlantUMLWriter";
     private static final String MUSTACHE_GENERATOR =
             "com.metaobjects.generator.mustache.MustacheTemplateGenerator";
 
@@ -271,6 +337,14 @@ public String toString() {
      *  imports them from. */
     public static final String SUPPORT_PACKAGE = "com.metaobjects.generator.spring";
 
+    /** The classpath prefix the packaged api-docs templates are read from, and an owned copy's
+     *  template provider is pointed away from (see {@link GeneratorInfo#ejectResources()}). */
+    public static final String TEMPLATE_RESOURCE_PREFIX = "templates/";
+
+    /** Classpath root the template sources are shipped under, one {@code <ref>.md.mustache} per
+     *  reference, for {@code mvn metaobjects:eject} to copy. */
+    public static final String EJECT_TEMPLATE_RESOURCE_ROOT = EJECT_RESOURCE_ROOT + "templates/";
+
     /** Classpath root the support sources are shipped under, one {@code <SimpleName>.java}
      *  per class, for {@code mvn metaobjects:eject} to copy. */
     public static final String EJECT_SUPPORT_RESOURCE_ROOT = EJECT_RESOURCE_ROOT + "support/";
@@ -301,32 +375,29 @@ private static Map<String, GeneratorInfo> buildRegistry() {
                     + "com.metaobjects.object.extract, so the consuming module needs a "
                     + "`metaobjects-om` dependency — without it the generated parser does not "
                     + "compile and nothing in the build says why.]", Tier.NATIVE, Layer.CAPABILITY,
-                ejectPath(SpringOutputParserGenerator.class));
+                ejectPath(SpringOutputParserGenerator.class), List.of(), null, ENUM_EMIT);
         register(m, "output-prompt", SpringOutputPromptGenerator.class.getName(),
                 "Per-template output-format prompt fragment generator.", Tier.NATIVE, Layer.CAPABILITY,
-                ejectPath(SpringOutputPromptGenerator.class));
+                ejectPath(SpringOutputPromptGenerator.class), List.of(), null, PROMPT_EMIT);
         register(m, "render-helper", SpringRenderHelperGenerator.class.getName(),
                 "Per-renderable-template render helper (typed wrappers; document/email for a template.output, the document shape for a template.prompt).", Tier.NATIVE, Layer.CAPABILITY,
                 ejectPath(SpringRenderHelperGenerator.class));
-        // "extractor" is a generator of its own AND a step "entity" runs when no separate
-        // one is in the run (EmitsObjectExtractors), so an existing pom that wires only
-        // "entity" emits what it always did. The note is what eject prints: unlike every
-        // other generator there may be no <generator> entry to change, only one to add.
+        // "extractor" is the one thing that writes the <Name>Extractor classes. Through 8.0
+        // "entity" wrote them for a pom that listed no extractor; a file nothing declares is
+        // what ADR-0034 Amendment 9 rules out. The note is what eject prints: a pom carried
+        // over from 8.0 may have no <generator> entry to change, only one to add.
         register(m, "extractor", ExtractorCodeGenerator.class.getName(),
                 "Per-object typed <Name>Extractor: tolerant recovery of the typed, flavored object "
-                    + "graph from dirty model text; throws only when a @required field is lost. `entity` "
-                    + "writes these itself with a concrete flavor, unless this generator is in "
-                    + "<generators> too.", Tier.NATIVE, Layer.CAPABILITY,
+                    + "graph from dirty model text; throws only when a @required field is lost. Needs "
+                    + "`entity` with a concrete flavor in the same run.", Tier.NATIVE, Layer.CAPABILITY,
                 ejectPath(ExtractorCodeGenerator.class), List.of(),
-                "extractor: `entity` writes the <Name>Extractor classes itself unless a separate "
-                    + "extractor generator is in <generators>. If yours has no entry for one, add "
+                "extractor: only this generator writes the <Name>Extractor classes; `entity` does "
+                    + "not. If your <generators> has no entry for it, add "
                     + "<generator><classname>{owned}</classname></generator> with the same outputDir, "
                     + "pkgPrefix, pkgSuffix, namePrefix and nameSuffix args, and the same <filters>, as "
                     + "your entity generator: an extractor for an object entity wrote no class for does "
-                    + "not compile. `entity` then leaves those files to it. A pom with more than "
-                    + "one entity entry needs one extractor entry per entity entry, each with that "
-                    + "entry's outputDir, naming args and <filters>: a single extractor generator in "
-                    + "the run stops every entity entry writing its extractors.",
+                    + "not compile. A pom with more than one entity entry needs one extractor entry "
+                    + "per entity entry, each with that entry's outputDir, naming args and <filters>.",
                 OBJECT_NAMING);
         // "template" stays registered but is NOT ejectable: it is already a generic,
         // declaratively-configured primitive (Mustache template + output pattern) with no
@@ -343,12 +414,12 @@ private static Map<String, GeneratorInfo> buildRegistry() {
                 ejectPath(SpringRepositoryGenerator.class), List.of("FilterPredicate"));
         register(m, "dto", SpringDtoGenerator.class.getName(),
                 "Per-entity Spring DTO record.", Tier.NATIVE, Layer.MODEL,
-                ejectPath(SpringDtoGenerator.class), List.of("PatchValidationException"));
+                ejectPath(SpringDtoGenerator.class), List.of("PatchValidationException"), null, RECORD_EMIT);
         register(m, "value-object", SpringValueObjectGenerator.class.getName(),
                 "Per-value-object Spring record with jakarta constraints — the typed "
                     + "component the DTO/Patch bind for a field.object @storage:jsonb column, "
                     + "and a template's payload/response type.", Tier.NATIVE, Layer.MODEL,
-                ejectPath(SpringValueObjectGenerator.class));
+                ejectPath(SpringValueObjectGenerator.class), List.of(), null, RECORD_EMIT);
         register(m, "trace-helper", LlmTraceHelperGenerator.class.getName(),
                 "Per-entity typed record<Entity> LLM-trace helper (extract + buildLlmCallRow + persist; "
                     + "LlmCallBase-derived entities only).", Tier.NATIVE, Layer.CAPABILITY,
@@ -363,20 +434,31 @@ private static Map<String, GeneratorInfo> buildRegistry() {
                     + "for a hand-written consumer to reference instead of a string literal.", Tier.NATIVE, Layer.MODEL,
                 ejectPath(SpringNamesGenerator.class));
         // The generators below were wirable by class name and in no registry, so no catalog,
-        // eject command or test saw them (ADR-0034 Amendment 8). They are registered so the
-        // eject contract covers them. None ships eject source yet; "mustache" never will: it
-        // is deprecated in favour of "template".
+        // eject command or test saw them (ADR-0034 Amendment 8). Each is a generator and the writer
+        // that emits its file; eject copies both. "mustache" never ejects: it is deprecated in
+        // favour of "template".
+        register(m, "api-docs", JavaApiDocsGenerator.class.getName(),
+                "Per-entity/template SDK API reference (generated-code API; human + agent forms).",
+                Tier.NATIVE, Layer.DOCS, ejectPath(JavaApiDocsGenerator.class), List.of(), null,
+                API_DOCS_EMIT, API_DOCS_TEMPLATES);
         register(m, "plantuml", PLANTUML_GENERATOR,
-                "PlantUML class diagram of the object model.", Tier.NATIVE, Layer.DOCS);
+                "PlantUML class diagram of the object model.", Tier.NATIVE, Layer.DOCS,
+                EJECT_RESOURCE_ROOT + "PlantUMLGenerator.java", List.of(), null, List.of(PLANTUML_WRITER));
         register(m, "html-docs", MetaDataHtmlDocumentationGenerator.class.getName(),
                 "Single-page HTML reference of the registered metamodel types, read from the "
-                    + "type registry.", Tier.NATIVE, Layer.DOCS);
+                    + "type registry.", Tier.NATIVE, Layer.DOCS,
+                ejectPath(MetaDataHtmlDocumentationGenerator.class), List.of(), null,
+                List.of(MetaDataHtmlDocumentationWriter.class.getName()));
         register(m, "ai-docs", MetaDataAIDocumentationGenerator.class.getName(),
                 "JSON reference of the registered metamodel types written for an AI reader, "
-                    + "read from the type registry.", Tier.NATIVE, Layer.DOCS);
+                    + "read from the type registry.", Tier.NATIVE, Layer.DOCS,
+                ejectPath(MetaDataAIDocumentationGenerator.class), List.of(), null,
+                List.of(MetaDataAIDocumentationWriter.class.getName()));
         register(m, "json-schema", MetaDataFileJsonSchemaGenerator.class.getName(),
                 "JSON Schema that validates metadata files, read from the type registry.",
-                Tier.NATIVE, Layer.CAPABILITY);
+                Tier.NATIVE, Layer.CAPABILITY,
+                ejectPath(MetaDataFileJsonSchemaGenerator.class), List.of(), null,
+                List.of(MetaDataFileSchemaWriter.class.getName()));
         register(m, "mustache", MUSTACHE_GENERATOR,
                 "The pre-`template` Mustache generator, kept so a pom that names its class keeps "
                     + "building. Deprecated: use `template`.", Tier.NATIVE, Layer.CAPABILITY);
@@ -405,8 +487,16 @@ private static void register(Map<String, GeneratorInfo> m, String stableName,
                                  String classname, String description, Tier tier, Layer layer,
                                  String ejectResourcePath, List<String> ejectRuntime,
                                  String ejectNote, List<String> ejectWith) {
+        register(m, stableName, classname, description, tier, layer, ejectResourcePath,
+                ejectRuntime, ejectNote, ejectWith, List.of());
+    }
+
+    private static void register(Map<String, GeneratorInfo> m, String stableName,
+                                 String classname, String description, Tier tier, Layer layer,
+                                 String ejectResourcePath, List<String> ejectRuntime,
+                                 String ejectNote, List<String> ejectWith, List<String> ejectResources) {
         if (m.put(stableName, new GeneratorInfo(stableName, classname, description, tier, layer,
-                ejectResourcePath, ejectRuntime, ejectNote, ejectWith)) != null) {
+                ejectResourcePath, ejectRuntime, ejectNote, ejectWith, ejectResources)) != null) {
             throw new IllegalStateException("duplicate generator stable name: " + stableName);
         }
     }
diff --git a/server/java/codegen-spring/src/main/java/com/metaobjects/generator/apidocs/GeneratorApplicability.java b/server/java/codegen-spring/src/main/java/com/metaobjects/generator/apidocs/GeneratorApplicability.java
new file mode 100644
index 000000000..2009bdd71
--- /dev/null
+++ b/server/java/codegen-spring/src/main/java/com/metaobjects/generator/apidocs/GeneratorApplicability.java
@@ -0,0 +1,55 @@
+package com.metaobjects.generator.apidocs;
+
+import com.metaobjects.generator.spring.LlmTraceHelperGenerator;
+import com.metaobjects.generator.spring.SpringControllerGenerator;
+import com.metaobjects.generator.spring.SpringDtoGenerator;
+import com.metaobjects.generator.spring.SpringFilterAllowlistGenerator;
+import com.metaobjects.generator.spring.SpringOutputParserGenerator;
+import com.metaobjects.generator.spring.SpringOutputPromptGenerator;
+import com.metaobjects.generator.spring.SpringRenderHelperGenerator;
+import com.metaobjects.loader.MetaDataLoader;
+import com.metaobjects.MetaData;
+import com.metaobjects.object.MetaObject;
+
+import java.util.function.BiPredicate;
+import java.util.function.Predicate;
+
+/**
+ * What the api reference asks of the generators it documents: would you emit for this?
+ *
+ * <p>The reference documents the code the OTHER generators emit, and it decides what to document
+ * by asking each of them the static {@code appliesTo} every one of those generators exposes. The
+ * docs generator does not name those generators. It reads the answers from here, so the docs
+ * generator, packaged or ejected, depends on nothing but this engine surface, and the reference
+ * describes what the packaged generators emit for, including in a project that owns a copy of one
+ * of them. {@link #packaged()} carries the packaged generators' own predicates.</p>
+ *
+ * @param dto             {@code dto}: the object's DTO record
+ * @param routes          {@code routes}: the object's controller
+ * @param filterAllowlist {@code filter-allowlist}: the object's filter allowlist
+ * @param traceHelper     {@code trace-helper}: the object's LLM-trace helper
+ * @param renderHelper    {@code render-helper}: the template's render helper
+ * @param outputPrompt    {@code output-prompt}: the template's response-format fragment
+ * @param outputParser    {@code output-parser}: the template's reply parser
+ */
+public record GeneratorApplicability(
+        Predicate<MetaObject> dto,
+        Predicate<MetaObject> routes,
+        Predicate<MetaObject> filterAllowlist,
+        Predicate<MetaObject> traceHelper,
+        BiPredicate<MetaData, MetaDataLoader> renderHelper,
+        BiPredicate<MetaData, MetaDataLoader> outputPrompt,
+        BiPredicate<MetaData, MetaDataLoader> outputParser) {
+
+    /** The packaged generators' own predicates. */
+    public static GeneratorApplicability packaged() {
+        return new GeneratorApplicability(
+                SpringDtoGenerator::appliesTo,
+                SpringControllerGenerator::appliesTo,
+                SpringFilterAllowlistGenerator::appliesTo,
+                LlmTraceHelperGenerator::appliesTo,
+                SpringRenderHelperGenerator::appliesTo,
+                SpringOutputPromptGenerator::appliesTo,
+                SpringOutputParserGenerator::appliesTo);
+    }
+}
diff --git a/server/java/codegen-spring/src/main/java/com/metaobjects/generator/apidocs/JavaApiDocsGenerator.java b/server/java/codegen-spring/src/main/java/com/metaobjects/generator/apidocs/JavaApiDocsGenerator.java
new file mode 100644
index 000000000..ef7f2764c
--- /dev/null
+++ b/server/java/codegen-spring/src/main/java/com/metaobjects/generator/apidocs/JavaApiDocsGenerator.java
@@ -0,0 +1,95 @@
+package com.metaobjects.generator.apidocs;
+
+// Eject note (ADR-0034 Amendment 8): `mvn metaobjects:eject -Dnames=api-docs` copies this file with the
+// api reference's IR, builder, renderer and templates. The siblings below stay in their packages as
+// engine, so each is imported by name — a bare same-package reference would not resolve from the copy.
+import com.metaobjects.generator.FileEmittingGenerator;
+import com.metaobjects.generator.GeneratorException;
+import com.metaobjects.generator.apidocs.GeneratorApplicability;
+import com.metaobjects.loader.MetaDataLoader;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * {@code api-docs} — the Java SDK api reference (the {@code api/java} surface of the cross-port
+ * SDK-docs contract): one page per entity, value object, projection, served report and template,
+ * an index, and the agent-facing {@code AGENT-API.md}.
+ *
+ * <p>An ordinary generator: a {@code <generator>} entry in the list {@code mvn
+ * metaobjects:generate} runs, and nothing writes these pages for a pom that does not list it
+ * (ADR-0034 Amendment 9). Its files land under {@code outputDir} in {@link #ARG_API_SUBDIR}; the
+ * project label, the layout and the model back-link base are the other {@code <args>} below.
+ * Give it an {@code outputDir} that holds generated files only: {@code mvn metaobjects:verify}
+ * compares each output directory as one tree, so a hand-written page there reads as stale.</p>
+ *
+ * <p>What each documented generator emits for comes from {@link #applicability}, so this
+ * generator names no emitting generator. The default is the packaged generators' answers. A
+ * project that owns a copy of one of them changes that one line of its copy of this class to ask
+ * its own.</p>
+ */
+public final class JavaApiDocsGenerator extends FileEmittingGenerator {
+
+    /** Arg: the label the agent page carries in its header. Default {@code project}. */
+    public static final String ARG_PROJECT_NAME = "projectName";
+
+    /** Arg: where under {@code outputDir} the pages land. Default {@link #DEFAULT_API_SUBDIR}. */
+    public static final String ARG_API_SUBDIR = "apiSubDir";
+
+    /** Arg: the page layout, {@code flat} (one file per unit, the default) or {@code package}. */
+    public static final String ARG_LAYOUT = "layout";
+
+    /** Arg: when set, the base URL the pages' links to the model pages are written against. */
+    public static final String ARG_MODEL_BASE_URL = "modelBaseUrl";
+
+    /** The api-surface subdirectory of the cross-port docs contract. */
+    public static final String DEFAULT_API_SUBDIR = "api/java";
+
+    private static final String LAYOUT_FLAT = "flat";
+    private static final String LAYOUT_PACKAGE = "package";
+
+    /** What each documented generator emits for. Replace it to describe an owned copy. */
+    private final GeneratorApplicability applicability = GeneratorApplicability.packaged();
+
+    @Override
+    protected List<EmittedFile> generate(MetaDataLoader loader) {
+        String project = getArg(ARG_PROJECT_NAME, "project");
+        String subDir = getArg(ARG_API_SUBDIR, DEFAULT_API_SUBDIR);
+        String modelBaseUrl = hasArg(ARG_MODEL_BASE_URL) ? getArg(ARG_MODEL_BASE_URL) : null;
+        DocsPaths.Layout layout = layoutOf(getArg(ARG_LAYOUT, LAYOUT_FLAT));
+
+        JavaApiModel model = new JavaApiModelBuilder(applicability).build(loader, project);
+        JavaApiDocsRenderer renderer = new JavaApiDocsRenderer();
+
+        List<EmittedFile> pages = new ArrayList<>();
+        Set<String> paths = new HashSet<>();
+        for (ApiUnit unit : model.units()) {
+            String pagePath = DocsPaths.docPageOutputPath(layout, unit.pkg(), unit.node());
+            String modelHref = DocsPaths.modelCrossHref(subDir + "/" + pagePath, pagePath, modelBaseUrl);
+            add(pages, paths, subDir, pagePath, renderer.renderUnitPage(unit, modelHref));
+        }
+        add(pages, paths, subDir, "README.md", renderer.renderIndex(model, layout));
+        add(pages, paths, subDir, "AGENT-API.md", renderer.renderAgentApi(model));
+        return pages;
+    }
+
+    /** The layout a {@link #ARG_LAYOUT} value names. A value that names none is refused: a
+     *  misspelt layout would otherwise write every page somewhere its links do not point. */
+    private static DocsPaths.Layout layoutOf(String value) {
+        if (LAYOUT_FLAT.equals(value)) return DocsPaths.Layout.FLAT;
+        if (LAYOUT_PACKAGE.equals(value)) return DocsPaths.Layout.PACKAGE;
+        throw new GeneratorException("api-docs: <" + ARG_LAYOUT + "> must be " + LAYOUT_FLAT + " or "
+                + LAYOUT_PACKAGE + " (got \"" + value + "\")");
+    }
+
+    /** Add one page, failing on a path two units resolve to. */
+    private static void add(List<EmittedFile> pages, Set<String> paths, String subDir, String pagePath,
+                            String content) {
+        if (!paths.add(pagePath)) {
+            throw new GeneratorException("api-docs: duplicate api page output path: " + pagePath);
+        }
+        pages.add(new EmittedFile(subDir + "/" + pagePath, content));
+    }
+}
diff --git a/server/java/codegen-spring/src/main/java/com/metaobjects/generator/apidocs/JavaApiModelBuilder.java b/server/java/codegen-spring/src/main/java/com/metaobjects/generator/apidocs/JavaApiModelBuilder.java
index ea5b7c156..9bc854ebd 100644
--- a/server/java/codegen-spring/src/main/java/com/metaobjects/generator/apidocs/JavaApiModelBuilder.java
+++ b/server/java/codegen-spring/src/main/java/com/metaobjects/generator/apidocs/JavaApiModelBuilder.java
@@ -1,15 +1,11 @@
 package com.metaobjects.generator.apidocs;
 
+// Eject note (ADR-0034 Amendment 8): `mvn metaobjects:eject` copies this file with the rest of the
+// api reference. The siblings below stay in their packages as engine, so each is imported by name.
+import com.metaobjects.generator.apidocs.GeneratorApplicability;
 import com.metaobjects.generator.spring.FindInbound;
-import com.metaobjects.generator.spring.LlmTraceHelperGenerator;
-import com.metaobjects.generator.spring.SpringControllerGenerator;
-import com.metaobjects.generator.spring.SpringDtoGenerator;
-import com.metaobjects.generator.spring.SpringFilterAllowlistGenerator;
 import com.metaobjects.generator.spring.SpringM2mSupport;
 import com.metaobjects.generator.spring.SpringNaming;
-import com.metaobjects.generator.spring.SpringOutputParserGenerator;
-import com.metaobjects.generator.spring.SpringOutputPromptGenerator;
-import com.metaobjects.generator.spring.SpringRenderHelperGenerator;
 import com.metaobjects.generator.spring.SpringGeneratorSupport;
 import com.metaobjects.io.util.IOUtil;
 import com.metaobjects.generator.util.GeneratorUtil;
@@ -82,6 +78,18 @@
  */
 public final class JavaApiModelBuilder {
 
+    private final GeneratorApplicability applies;
+
+    /** A builder that documents what the packaged generators emit for. */
+    public JavaApiModelBuilder() {
+        this(GeneratorApplicability.packaged());
+    }
+
+    /** @param applies what each documented generator emits for; see {@link GeneratorApplicability}. */
+    public JavaApiModelBuilder(GeneratorApplicability applies) {
+        this.applies = applies;
+    }
+
     /** Build the SDK-surface model for {@code project} from the loaded {@code loader}. */
     public JavaApiModel build(MetaDataLoader loader, String project) {
         List<ApiUnit> units = new ArrayList<>();
@@ -140,7 +148,7 @@ shortName, ApiSymbolKind.MODEL, fqn(javaPkg, shortName),
         // DTO — the wire shape. Emitted for any concrete object.entity OR concrete
         // object.projection (a projection is a read-only wire model). The inclusion
         // decision is delegated to the generator's appliesTo so documented == generated.
-        if (SpringDtoGenerator.appliesTo(obj)) {
+        if (applies.dto().test(obj)) {
             String dto = SpringNaming.dtoName(shortName);
             List<FieldShape> dtoFields = JavaFieldShapes.dtoFields(obj);
             symbols.add(symbolWithFields(
@@ -183,12 +191,12 @@ repo, ApiSymbolKind.DATA_ACCESS, fqn(javaPkg, repo),
         }
 
         // REST — one symbol per verb+path the controller registers.
-        if (SpringControllerGenerator.appliesTo(obj)) {
+        if (applies.routes().test(obj)) {
             addRestSymbols(symbols, obj, javaPkg, shortName, loader);
         }
 
         // FILTER — the per-entity sort/filter allowlist.
-        if (SpringFilterAllowlistGenerator.appliesTo(obj)) {
+        if (applies.filterAllowlist().test(obj)) {
             String filter = SpringNaming.filterAllowlistName(shortName);
             symbols.add(symbol(
                 filter, ApiSymbolKind.FILTER, fqn(javaPkg, filter),
@@ -198,7 +206,7 @@ filter, ApiSymbolKind.FILTER, fqn(javaPkg, filter),
 
         // TRACE — the LLM-trace persistence helper (only when a prompt with
         // @responseRef is present, per the generator's appliesTo).
-        if (LlmTraceHelperGenerator.appliesTo(obj)) {
+        if (applies.traceHelper().test(obj)) {
             String trace = SpringNaming.traceHelperName(shortName);
             symbols.add(symbol(
                 trace, ApiSymbolKind.TRACE, fqn(javaPkg, trace),
@@ -306,7 +314,7 @@ private ApiUnit buildTemplateUnit(MetaTemplate tmpl, MetaDataLoader loader) {
                 "the typed payload value object the template renders",
                 JavaFieldShapes.payloadFieldsOf(payloadVo, loader)));
         }
-        if (SpringRenderHelperGenerator.appliesTo(tmpl, loader)) {
+        if (applies.renderHelper().test(tmpl, loader)) {
             String render = SpringNaming.renderHelperName(shortName);
             // The render helper's return type keys off @kind: email → EmailDocument,
             // document (the default) → String. Read the own attr the same way the
@@ -319,14 +327,14 @@ render, ApiSymbolKind.RENDER, fqn(promptsPkg, render),
                 renderReturns));
         }
         // ADR-0052: the inbound symbols belong to the RESPONDING PROMPT, never to an output.
-        if (SpringOutputPromptGenerator.appliesTo(tmpl, loader)) {
+        if (applies.outputPrompt().test(tmpl, loader)) {
             String prompt = SpringNaming.responseFormatName(shortName);
             symbols.add(symbol(
                 prompt, ApiSymbolKind.PROMPT, fqn(promptsPkg, prompt),
                 "final class " + prompt,
                 "builds the response-format prompt fragment"));
         }
-        if (SpringOutputParserGenerator.appliesTo(tmpl, loader)) {
+        if (applies.outputParser().test(tmpl, loader)) {
             String parser = SpringNaming.parserName(shortName);
             symbols.add(symbol(
                 parser, ApiSymbolKind.OUTPUT_PARSER, fqn(promptsPkg, parser),
diff --git a/server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/Fr019SharedEnum.java b/server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/Fr019SharedEnum.java
index f84d91a83..48d7abd9f 100644
--- a/server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/Fr019SharedEnum.java
+++ b/server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/Fr019SharedEnum.java
@@ -1,10 +1,15 @@
 package com.metaobjects.generator.spring;
 
+// Eject note (ADR-0034 Amendment 8): `mvn metaobjects:eject` copies this file with the generators
+// that call it. The naming and type-mapping siblings stay in com.metaobjects.generator.spring, so
+// they are imported by name — a bare same-package reference would not resolve from the copy.
 import com.metaobjects.field.EnumField;
 import com.metaobjects.field.MetaField;
 import com.metaobjects.generator.GeneratorException;
 import com.metaobjects.generator.util.GeneratedFileWriter;
 import com.metaobjects.generator.util.GeneratorUtil;
+import com.metaobjects.generator.spring.SpringNaming;
+import com.metaobjects.generator.spring.SpringTypeMapper;
 import com.metaobjects.loader.MetaDataLoader;
 import com.metaobjects.object.MetaObject;
 
diff --git a/server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/OutputFormatSpecEmitter.java b/server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/OutputFormatSpecEmitter.java
index 41380cc82..5bcc6d341 100644
--- a/server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/OutputFormatSpecEmitter.java
+++ b/server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/OutputFormatSpecEmitter.java
@@ -1,5 +1,9 @@
 package com.metaobjects.generator.spring;
 
+// Eject note (ADR-0034 Amendment 8): `mvn metaobjects:eject` copies this file with the
+// output-prompt generator. FindInbound stays in com.metaobjects.generator.spring as engine, so it
+// is imported by name — a bare same-package reference would not resolve from the copy.
+import com.metaobjects.generator.spring.FindInbound;
 import com.metaobjects.field.BooleanField;
 import com.metaobjects.field.DoubleField;
 import com.metaobjects.field.EnumField;
diff --git a/server/java/codegen-spring/src/test/java/com/metaobjects/generator/apidocs/ApiDocsCrossPortConformanceTest.java b/server/java/codegen-spring/src/test/java/com/metaobjects/generator/apidocs/ApiDocsCrossPortConformanceTest.java
index 70371040e..50b7334a6 100644
--- a/server/java/codegen-spring/src/test/java/com/metaobjects/generator/apidocs/ApiDocsCrossPortConformanceTest.java
+++ b/server/java/codegen-spring/src/test/java/com/metaobjects/generator/apidocs/ApiDocsCrossPortConformanceTest.java
@@ -32,7 +32,7 @@
  * <p>This test is the JAVA half. It loads the SAME input metadata
  * ({@code fixtures/conformance/api-docs-cross-port/input/meta.json}) the TS side loads,
  * builds the {@link JavaApiModel}, and for each manifest unit asserts — using the EXACT
- * path/href math the {@code metaobjects:docs} goal ({@code DocsMojo}) uses, computed via
+ * path/href math the {@code api-docs} generator ({@code JavaApiDocsGenerator}) uses, computed via
  * {@link DocsPaths}, never re-derived here — that:
  * <ul>
  *   <li>{@code apiSubDir + "/" + docPageOutputPath(PACKAGE, pkg, node)} equals the
@@ -118,7 +118,7 @@ public void javaApiJavaPathsAndHrefsMatchTheSharedManifest() throws Exception {
             manifestNodes, javaNodes);
 
         // ---- per-unit: api/java path + model back-href match the manifest EXACTLY ----
-        // Path/href math mirrors DocsMojo with layout=package, apiSubDir="api/java",
+        // Path/href math mirrors JavaApiDocsGenerator with layout=package, apiSubDir="api/java",
         // modelBaseUrl=null — every value from DocsPaths, nothing re-derived here.
         JavaApiDocsRenderer renderer = new JavaApiDocsRenderer();
         List<String> checked = new ArrayList<>();
diff --git a/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/CodegenCompileConformanceTest.java b/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/CodegenCompileConformanceTest.java
index 1c3ecc3d0..922fed388 100644
--- a/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/CodegenCompileConformanceTest.java
+++ b/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/CodegenCompileConformanceTest.java
@@ -1,6 +1,5 @@
 package com.metaobjects.generator.spring;
 
-import com.metaobjects.generator.EmitsObjectExtractors;
 import com.metaobjects.generator.direct.object.javacode.ExtractorCodeGenerator;
 import com.metaobjects.generator.direct.object.javacode.JavaObjectCodeGenerator;
 import com.metaobjects.generator.Generator;
@@ -184,17 +183,14 @@ public void theJavaModelTierCompiles() throws Exception {
     }
 
     /**
-     * The same model tier with the extractors written by the {@code extractor} generator
-     * instead of by {@code entity}. One emitter per file is what a pom holding both gets
-     * (the Maven plugin derives the arg), so it is what is compiled here: a standalone
-     * extractor that named a class {@code entity} did not emit would fail this compile.
+     * The same model tier with the {@code extractor} generator listed beside {@code entity},
+     * which is the only way the extractors are written: an extractor that named a class
+     * {@code entity} did not emit would fail this compile.
      */
     @Test
-    public void theJavaModelTierCompilesWithTheExtractorsFromTheirOwnGenerator() throws Exception {
-        Map<String, String> entityOnly = new LinkedHashMap<>(AS_CLASS);
-        entityOnly.put(EmitsObjectExtractors.ARG_EMIT_EXTRACTORS, "false");
+    public void theJavaModelTierCompilesWithTheExtractorGeneratorBesideIt() throws Exception {
         Map<String, Map<String, String>> selection = new LinkedHashMap<>();
-        selection.put("entity", entityOnly);
+        selection.put("entity", AS_CLASS);
         selection.put("extractor", PLAIN);
         selection.put("names", PLAIN);
         generateAndCompile("model-split", selection, 17, "ProgramExtractor");
diff --git a/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/GeneratedExtractorCompileRunTest.java b/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/GeneratedExtractorCompileRunTest.java
index fbd01b2fc..2727bb845 100644
--- a/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/GeneratedExtractorCompileRunTest.java
+++ b/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/GeneratedExtractorCompileRunTest.java
@@ -1,5 +1,6 @@
 package com.metaobjects.generator.spring;
 
+import com.metaobjects.generator.direct.object.javacode.ExtractorCodeGenerator;
 import com.metaobjects.generator.direct.object.javacode.JavaObjectCodeGenerator;
 import com.metaobjects.loader.InMemoryStringSource;
 import com.metaobjects.loader.LoaderOptions;
@@ -136,7 +137,8 @@ private void runFlavor(String flavor, String loaderName) throws Exception {
         MetaObject answerMo = loader.getMetaObjectByName(ANSWER_FQN);
         assertNotNull("Answer MetaObject must load", answerMo);
 
-        // 1. Generate flavored classes + provider + Extractor.
+        // 1. Generate flavored classes + provider (`entity`) and the Extractor (`extractor`),
+        //    the two <generator> entries a pom lists, over one output directory.
         Path gen = tmp.newFolder("gen-" + flavor).toPath();
         Map<String, String> args = new HashMap<>();
         args.put("outputDir", gen.toString());
@@ -147,6 +149,10 @@ private void runFlavor(String flavor, String loaderName) throws Exception {
         generator.setArgs(args);
         generator.execute(loader);
 
+        ExtractorCodeGenerator extractorGenerator = new ExtractorCodeGenerator();
+        extractorGenerator.setArgs(Map.of("outputDir", gen.toString()));
+        extractorGenerator.execute(loader);
+
         // The Extractor must have been emitted alongside the flavored class.
         File extractorSrc = gen.resolve("acme/payload/AnswerExtractor.java").toFile();
         assertTrue("AnswerExtractor.java must be emitted for flavor=" + flavor + " at " + extractorSrc,
diff --git a/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/NoMagicPhysicalNamesTest.java b/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/NoMagicPhysicalNamesTest.java
index 7a669645c..e30031d40 100644
--- a/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/NoMagicPhysicalNamesTest.java
+++ b/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/NoMagicPhysicalNamesTest.java
@@ -1,6 +1,5 @@
 package com.metaobjects.generator.spring;
 
-import com.metaobjects.generator.EmitsObjectExtractors;
 import com.metaobjects.generator.EmitsPhysicalNameConstants;
 import com.metaobjects.generator.Generator;
 import com.metaobjects.generator.GeneratorRegistry;
@@ -461,10 +460,8 @@ private Map<String, String> generate() throws Exception {
             new TreeSet<>(GeneratorRegistryConformanceTest.NOT_WIRABLE), notGenerators);
         // Derive `useNames` from the suite through the SHIPPED helper — the identical call
         // AbstractMetaDataMojo.buildGenerators makes. Re-implementing it here would leave
-        // the gate measuring the test's own logic. The same goes for who writes the
-        // extractors: the registry holds both `entity` and `extractor`, as a pom may.
-        Map<String, String> runArgs = EmitsObjectExtractors.deriveEmitExtractors(
-            EmitsPhysicalNameConstants.deriveUseNames(args, suite), suite);
+        // the gate measuring the test's own logic.
+        Map<String, String> runArgs = EmitsPhysicalNameConstants.deriveUseNames(args, suite);
         for (Generator g : suite) {
             Map<String, String> own = new HashMap<>(runArgs);
             // A generator that writes ONE file is told its name; a per-object generator
diff --git a/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/OwnedPathNeverReachesPackagedSupportTest.java b/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/OwnedPathNeverReachesPackagedSupportTest.java
index 702aa58bb..085cf79d5 100644
--- a/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/OwnedPathNeverReachesPackagedSupportTest.java
+++ b/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/OwnedPathNeverReachesPackagedSupportTest.java
@@ -70,11 +70,25 @@ private Set<String> ejectableGenerators() {
         return out;
     }
 
+    /** The classes eject copies WITH an ejectable generator of this module ({@code ejectWith}): they
+     *  are owned beside it, so reaching one is not reaching packaged code. */
+    private Set<String> copiedWithGenerators() {
+        Set<String> out = new TreeSet<>();
+        for (GeneratorInfo info : GeneratorRegistry.list().values()) {
+            if (info.ejectResourcePath() == null || !Files.exists(classFile(info.classname()))) continue;
+            for (String with : info.ejectWith()) {
+                if (Files.exists(classFile(with))) out.add(with);
+            }
+        }
+        return out;
+    }
+
     @Test
     public void noPackagedClassAnOwnedGeneratorReachesRefersBackToTheSupportClass() throws IOException {
         Set<String> support = support();
         Set<String> owned = new TreeSet<>(support);
         owned.addAll(ejectableGenerators());
+        owned.addAll(copiedWithGenerators());
 
         Deque<String> queue = new ArrayDeque<>(owned);
         Set<String> seen = new HashSet<>(owned);
diff --git a/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/ReportingInertTest.java b/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/ReportingInertTest.java
index 9bd9e6970..955404283 100644
--- a/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/ReportingInertTest.java
+++ b/server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/ReportingInertTest.java
@@ -44,7 +44,7 @@
  * <p>Since Plan 3 a report that declares a read-only {@code source.rdb @kind: view} is
  * SERVED: the REST-surface generators emit its read-only files and nothing else changes.
  * {@code StoreTotals} is that report, so {@code with/} differs from {@code without/} in
- * exactly {@link #SERVED_REPORT_FILES} (one file per generator) and one api-docs unit.
+ * exactly {@link #SERVED_REPORT_FILES} (one file per generator, the api-docs page among them).
  * {@code DailyRevenue}, {@code ProgramEngagement} and {@code ProgramCatalogue} (which declares
  * {@code @spine} and lists a dimension reached by {@code @via}) declare no source and stay
  * inert, as does a measure {@code @default} ({@code avgDaysPerStarter}).
@@ -72,7 +72,17 @@ public class ReportingInertTest extends SharedRegistryTestBase {
         "dto", "acme/shop/StoreTotalsDto.java",
         "repository", "acme/shop/StoreTotalsRepository.java",
         "filter-allowlist", "acme/shop/StoreTotalsFilterAllowlist.java",
-        "routes", "acme/shop/StoreTotalsController.java");
+        "routes", "acme/shop/StoreTotalsController.java",
+        // The api reference documents the served report as one more unit.
+        "api-docs", "api/java/StoreTotals.md");
+
+    /**
+     * The files that LIST every unit rather than describe one, by generator stable name: the api
+     * reference's index and agent page. They differ between the two models by the served report's
+     * entry, so each is checked to name it and then left out of the byte comparison.
+     */
+    private static final Map<String, List<String>> UNIT_LISTINGS = Map.of(
+        "api-docs", List.of("api/java/README.md", "api/java/AGENT-API.md"));
 
     private static Path model(String variant) {
         return SpringTestFixtures.findCorpusRoot().getParent()
@@ -178,8 +188,17 @@ public void everyGeneratorEmitsTheSameFilesButTheServedReportsOwn() throws Excep
             String extra = SERVED_REPORT_FILES.get(info.stableName());
             if (extra != null) seen.add(info.stableName());
             try {
-                assertSameBut(info.stableName(), emit("without", List.of(info)), emit("with", List.of(info)),
-                    extra == null ? List.of() : List.of(extra));
+                Map<String, String> without = emit("without", List.of(info));
+                Map<String, String> with = emit("with", List.of(info));
+                for (String listing : UNIT_LISTINGS.getOrDefault(info.stableName(), List.of())) {
+                    assertTrue(info.stableName() + ": " + listing + " does not name the served report",
+                        with.getOrDefault(listing, "").contains("StoreTotals"));
+                    assertFalse(info.stableName() + ": " + listing + " names the report without it",
+                        without.getOrDefault(listing, "").contains("StoreTotals"));
+                    without.remove(listing);
+                    with.remove(listing);
+                }
+                assertSameBut(info.stableName(), without, with, extra == null ? List.of() : List.of(extra));
             } catch (AssertionError e) {
                 leaks.add(e.getMessage());
             }
@@ -238,7 +257,7 @@ public void theModelAndWebTiersInOneRunEmitTheSameFiles() throws Exception {
     }
 
     /**
-     * The api docs surface ({@code mvn metaobjects:docs}): every unit page, the index and the
+     * The api docs surface (the {@code api-docs} generator): every unit page, the index and the
      * agent page.
      */
     private Map<String, String> apiDocs(String variant) throws Exception {
diff --git a/server/java/maven-plugin/pom.xml b/server/java/maven-plugin/pom.xml
index dfe7ad280..b6f8aa5e4 100644
--- a/server/java/maven-plugin/pom.xml
+++ b/server/java/maven-plugin/pom.xml
@@ -75,9 +75,9 @@
             <artifactId>metaobjects-codegen-plantuml</artifactId>
             <version>${project.version}</version>
         </dependency>
-        <!-- api-docs IR/builder/renderer/DocsPaths for the metaobjects:docs goal: the Java
-             surface (codegen-spring) + the Kotlin surface (codegen-kotlin). The Kotlin api-docs
-             builder/renderer/DocsPaths drive the goal's language=kotlin emit. -->
+        <!-- The Java (codegen-spring) and Kotlin (codegen-kotlin) generators, the api-docs
+             generators among them, which a pom lists in <generators> and
+             metaobjects:generate runs. -->
         <dependency>
             <groupId>com.metaobjects</groupId>
             <artifactId>metaobjects-codegen-spring</artifactId>
@@ -154,6 +154,15 @@
             <version>3.0.2</version>
             <scope>test</scope>
         </dependency>
+        <!-- ApiDocsEjectBothPortsTest compiles the Kotlin api-docs copy the eject mojo writes
+             beside the Java one. Same compiler harness, at the same version, as codegen-kotlin's
+             own eject tests. -->
+        <dependency>
+            <groupId>com.github.tschuchortdev</groupId>
+            <artifactId>kotlin-compile-testing</artifactId>
+            <version>1.6.0</version>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.apache.derby</groupId>
             <artifactId>derby</artifactId>
diff --git a/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/AbstractMetaDataMojo.java b/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/AbstractMetaDataMojo.java
index 96a6f3339..edce9e7fb 100644
--- a/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/AbstractMetaDataMojo.java
+++ b/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/AbstractMetaDataMojo.java
@@ -14,7 +14,6 @@
 import com.metaobjects.loader.LoaderConfigurable;
 import com.metaobjects.loader.LoaderConfigurationConstants;
 import com.metaobjects.loader.LoaderOptions;
-import com.metaobjects.generator.EmitsObjectExtractors;
 import com.metaobjects.generator.EmitsPhysicalNameConstants;
 import com.metaobjects.loader.MetaDataLoader;
 import org.apache.maven.plugin.AbstractMojo;
@@ -109,12 +108,47 @@ public void setLax(boolean lax) {
         this.lax = lax;
     }
 
+    // The parameters of the `docs` goal removed in 8.1.0 (ADR-0034 Amendment 9), which nothing
+    // reads. They are declared so that a pom still setting one is refused by name: Maven drops
+    // an element no goal declares without a word, and the build would then write no
+    // documentation and say nothing. (The goal's fifth parameter, <outputDirectory>, is this
+    // class's own build directory and cannot be told apart.)
+    @Parameter(property = "metaobjects.docs.language")
+    private String language;
+    @Parameter(property = "metaobjects.docs.apiSubDir")
+    private String apiSubDir;
+    @Parameter(property = "metaobjects.docs.layout")
+    private String layout;
+    @Parameter(property = "metaobjects.docs.modelBaseUrl")
+    private String modelBaseUrl;
+
+    /**
+     * Refuse a pom that still carries the removed {@code docs} goal's configuration. ADR-0034
+     * Amendment 9 fixes the sentence for every port.
+     *
+     * @param goal the goal refusing, as the adopter typed it ({@code generate}, {@code verify})
+     */
+    protected void refuseRemovedDocsConfiguration(String goal) throws MojoFailureException {
+        List<String> set = new ArrayList<>();
+        if (language != null) set.add("<language>");
+        if (apiSubDir != null) set.add("<apiSubDir>");
+        if (layout != null) set.add("<layout>");
+        if (modelBaseUrl != null) set.add("<modelBaseUrl>");
+        if (set.isEmpty()) return;
+        throw new MojoFailureException(
+                "metaobjects:" + goal + ": found 1.0 docs configuration (" + String.join(", ", set)
+                    + " in the plugin's <configuration>). Nothing reads it any more, so this run would "
+                    + "write no documentation. Declare each docs generator as a <generator> entry in the "
+                    + "plugin's <generators>. See " + DocsMojo.MIGRATION + ".");
+    }
+
     public void execute() throws MojoExecutionException, MojoFailureException
     {
         // #233: warm the global registry singletons before this reactor module's load
         // can race a sibling module's first-init under `mvn -T`. Must precede
         // createLoader(), which triggers MavenLoaderConfiguration's eager
         // getTypeRegistry().getRegisteredTypes() first-touch on this thread.
+        refuseRemovedDocsConfiguration( execution != null ? execution.getGoal() : "generate" );
         com.metaobjects.registry.RegistryBootstrap.warmUpDefaults();
         if ( getLoader() == null ) {
             throw new MojoExecutionException( "No <loader> element was defined");
@@ -200,16 +234,9 @@ protected List<Generator> buildGenerators(ClassLoader projectClassLoader,
         // aggregation point that makes it safe to default from the run instead: the same
         // decision TypeScript makes from its `emitsNames` generator marker and C# from
         // GeneratorRegistry.IncludesNames. An explicit `<useNames>` in the pom still wins.
-        //
-        // The same aggregation answers a second question for the Java `entity` generator: is
-        // a separate `extractor` generator in this run? `entity` writes the <Name>Extractor
-        // classes itself unless one is, so a run holding both has one emitter per file
-        // rather than two that agree until the owned one is edited.
         for ( int i = 0; i < generatorImpls.size(); i++ ) {
-            Map<String, String> derived =
-                EmitsPhysicalNameConstants.deriveUseNames( argsByGenerator.get(i), generatorImpls );
             generatorImpls.get(i).setArgs(
-                EmitsObjectExtractors.deriveEmitExtractors( derived, generatorImpls ) );
+                EmitsPhysicalNameConstants.deriveUseNames( argsByGenerator.get(i), generatorImpls ) );
         }
 
         return generatorImpls;
diff --git a/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/DocsMojo.java b/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/DocsMojo.java
index 91ee95df7..814499982 100644
--- a/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/DocsMojo.java
+++ b/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/DocsMojo.java
@@ -1,218 +1,36 @@
 package com.metaobjects.mojo;
 
-import com.metaobjects.generator.Generator;
-import com.metaobjects.loader.MetaDataLoader;
-import org.apache.maven.plugin.MojoExecutionException;
+import org.apache.maven.plugin.AbstractMojo;
 import org.apache.maven.plugin.MojoFailureException;
 import org.apache.maven.plugins.annotations.LifecyclePhase;
 import org.apache.maven.plugins.annotations.Mojo;
-import org.apache.maven.plugins.annotations.Parameter;
-import org.apache.maven.plugins.annotations.ResolutionScope;
-
-import java.io.IOException;
-import java.io.UncheckedIOException;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
 
 /**
- * {@code metaobjects:docs} — emit the generated SDK api surface (the SP-1 {@code apiSurfaces}
- * surface) into a configurable subdir, for one or more languages.
- *
- * <p>Extends {@link AbstractMetaDataMojo} so it inherits metadata loading from the
- * {@code <loader>} config: the base {@link AbstractMetaDataMojo#execute()} builds the
- * {@link MetaDataLoader} and then calls the {@link #executeGenerators(MetaDataLoader, List)}
- * hook. This goal needs only the loaded loader, not configured {@code <generators>}, so it
- * ignores the (empty) generator list and instead builds + renders the api-docs IR.
+ * {@code metaobjects:docs} — removed in 8.1.0 (ADR-0034 Amendment 9). The goal stays only to
+ * say so: a pom that still binds it fails with the line below, where a goal that was simply
+ * gone would fail with Maven's "could not find goal", which names neither what replaced it
+ * nor where the change is written down. It keeps the 8.0 goal's default phase: an execution
+ * that binds {@code <goal>docs</goal>} with no {@code <phase>} is scheduled through that phase,
+ * and without one Maven would skip the goal and the build would pass with no documentation.
  *
- * <p>The {@link #language} parameter selects the native SDK surface:
- * <ul>
- *   <li>{@code java} (default) — the {@code codegen-spring} Java surface ({@code api/java});</li>
- *   <li>{@code kotlin} — the {@code codegen-kotlin} Kotlin surface ({@code api/kotlin});</li>
- *   <li>{@code java,kotlin} — both surfaces, each into its own subdir.</li>
- * </ul>
- * Each language's surface defaults its own {@code apiSubDir} ({@code api/<lang>}); set
- * {@link #apiSubDir} explicitly only when documenting a single language into a custom dir.
- *
- * <p>The Mojo is wiring only: every name comes from the per-language IR and every path from that
- * port's {@code DocsPaths} (byte-parity with the TS contract) — nothing is re-derived here. Output
- * paths are collision-checked (duplicate page path → build failure), mirroring the TS
- * {@code assertNoDuplicateDocPaths}.
+ * <p>Documentation is generated the way code is: each docs generator is a {@code <generator>}
+ * entry in the list {@code metaobjects:generate} runs, with its options in {@code <args>}.</p>
  */
-@Mojo(name = "docs",
-        requiresDependencyResolution = ResolutionScope.COMPILE_PLUS_RUNTIME,
-        defaultPhase = LifecyclePhase.GENERATE_RESOURCES,
-        threadSafe = true)   // #233
-public class DocsMojo extends AbstractMetaDataMojo {
-
-    private static final String LANG_JAVA = "java";
-    private static final String LANG_KOTLIN = "kotlin";
-
-    /** Root output dir for docs; each surface lands under its {@code apiSubDir}. */
-    @Parameter(property = "metaobjects.docs.outputDirectory",
-            defaultValue = "${project.build.directory}/docs")
-    private java.io.File outputDirectory;
-
-    /**
-     * Which native SDK surface(s) to emit — comma-separated {@code java} / {@code kotlin}.
-     * Default {@code java} (back-compat: the goal emitted only {@code api/java} before the
-     * Kotlin surface landed).
-     */
-    @Parameter(property = "metaobjects.docs.language", defaultValue = LANG_JAVA)
-    private String language;
-
-    /**
-     * Subdir (under {@link #outputDirectory}) for the api surface. Unset → each language uses its
-     * own default ({@code api/<lang>}). Set this only when emitting a single language to a custom
-     * dir; with multiple languages an explicit value would collide and is rejected.
-     */
-    @Parameter(property = "metaobjects.docs.apiSubDir")
-    private String apiSubDir;
+@Mojo(name = "docs", defaultPhase = LifecyclePhase.GENERATE_RESOURCES, threadSafe = true)
+public class DocsMojo extends AbstractMojo {
 
-    /** Doc-page layout: {@code flat} (one file per unit) or {@code package} (foldered). */
-    @Parameter(property = "metaobjects.docs.layout", defaultValue = "flat")
-    private String layout;
+    /** Where the change to a 1.0 pom is written down, before and after. */
+    static final String MIGRATION =
+            "docs/features/migrations/docs-are-generators.md, section \"Java and Kotlin\"";
 
-    /** Optional base URL for federated model docs; when unset, model links are relative. */
-    @Parameter(property = "metaobjects.docs.modelBaseUrl")
-    private String modelBaseUrl;
+    /** What this goal prints. ADR-0034 Amendment 9 fixes the sentence for every port. */
+    static final String REMOVED =
+            "metaobjects:docs was removed in 8.1.0. `mvn metaobjects:generate` writes documentation "
+                + "now: declare each docs generator as a <generator> entry in the plugin's <generators>. "
+                + "See " + MIGRATION + ".";
 
     @Override
-    public void execute() throws MojoExecutionException, MojoFailureException {
-        // Inherit loader construction + the executeGenerators hook from the base.
-        super.execute();
-    }
-
-    @Override
-    protected void executeGenerators(MetaDataLoader loader, List<Generator> generatorImpls) {
-        // Default to java when unset (the MojoRule test harness does not apply @Parameter
-        // defaultValue; a real Maven run does — guard both paths).
-        String langSpec = (language == null || language.trim().isEmpty()) ? LANG_JAVA : language;
-        String[] langs = langSpec.split(",");
-        boolean multi = langs.length > 1;
-        if (multi && apiSubDir != null && !apiSubDir.isEmpty()) {
-            throw new IllegalStateException(
-                    "metaobjects:docs — an explicit <apiSubDir> cannot be shared across multiple "
-                            + "languages (" + language + "); omit it so each uses api/<lang>");
-        }
-
-        String projectName = project != null ? project.getArtifactId() : "project";
-        boolean packageLayout = "package".equalsIgnoreCase(layout);
-
-        for (String raw : langs) {
-            String lang = raw.trim().toLowerCase(Locale.ROOT);
-            if (lang.isEmpty()) {
-                continue;
-            }
-            String subDir = (apiSubDir != null && !apiSubDir.isEmpty()) ? apiSubDir : ("api/" + lang);
-            Map<String, String> emitted;
-            switch (lang) {
-                case LANG_JAVA:
-                    emitted = renderJava(loader, projectName, subDir, packageLayout);
-                    break;
-                case LANG_KOTLIN:
-                    emitted = renderKotlin(loader, projectName, subDir, packageLayout);
-                    break;
-                default:
-                    throw new IllegalStateException(
-                            "metaobjects:docs — unknown language '" + lang
-                                    + "' (supported: java, kotlin)");
-            }
-            writeSurface(subDir, emitted);
-        }
-    }
-
-    // ----- Java surface (codegen-spring) -------------------------------------
-
-    private Map<String, String> renderJava(MetaDataLoader loader, String projectName,
-                                           String subDir, boolean packageLayout) {
-        com.metaobjects.generator.apidocs.DocsPaths.Layout lay = packageLayout
-                ? com.metaobjects.generator.apidocs.DocsPaths.Layout.PACKAGE
-                : com.metaobjects.generator.apidocs.DocsPaths.Layout.FLAT;
-        com.metaobjects.generator.apidocs.JavaApiModel model =
-                new com.metaobjects.generator.apidocs.JavaApiModelBuilder().build(loader, projectName);
-        com.metaobjects.generator.apidocs.JavaApiDocsRenderer renderer =
-                new com.metaobjects.generator.apidocs.JavaApiDocsRenderer();
-
-        Map<String, String> emitted = new LinkedHashMap<>();
-        for (com.metaobjects.generator.apidocs.ApiUnit unit : model.units()) {
-            String pagePath = com.metaobjects.generator.apidocs.DocsPaths.docPageOutputPath(
-                    lay, unit.pkg(), unit.node());
-            String apiPagePathFromDocsRoot = subDir + "/" + pagePath;
-            String modelHref = com.metaobjects.generator.apidocs.DocsPaths.modelCrossHref(
-                    apiPagePathFromDocsRoot, pagePath, modelBaseUrl);
-            put(emitted, pagePath, renderer.renderUnitPage(unit, modelHref));
-        }
-        put(emitted, "README.md", renderer.renderIndex(model, lay));
-        put(emitted, "AGENT-API.md", renderer.renderAgentApi(model));
-        return emitted;
-    }
-
-    // ----- Kotlin surface (codegen-kotlin) -----------------------------------
-
-    private Map<String, String> renderKotlin(MetaDataLoader loader, String projectName,
-                                             String subDir, boolean packageLayout) {
-        com.metaobjects.generator.kotlin.apidocs.DocsPaths.Layout lay = packageLayout
-                ? com.metaobjects.generator.kotlin.apidocs.DocsPaths.Layout.PACKAGE
-                : com.metaobjects.generator.kotlin.apidocs.DocsPaths.Layout.FLAT;
-        com.metaobjects.generator.kotlin.apidocs.KotlinApiModel model =
-                new com.metaobjects.generator.kotlin.apidocs.KotlinApiModelBuilder(
-                        com.metaobjects.generator.kotlin.Fr019SharedEnum.ProvidedEnumConfig.fromArgs(getGlobals()))
-                        .build(loader, projectName);
-        com.metaobjects.generator.kotlin.apidocs.KotlinApiDocsRenderer renderer =
-                new com.metaobjects.generator.kotlin.apidocs.KotlinApiDocsRenderer();
-
-        Map<String, String> emitted = new LinkedHashMap<>();
-        for (com.metaobjects.generator.kotlin.apidocs.ApiUnit unit : model.getUnits()) {
-            String pagePath = com.metaobjects.generator.kotlin.apidocs.DocsPaths.INSTANCE
-                    .docPageOutputPath(lay, unit.getPkg(), unit.getNode());
-            String apiPagePathFromDocsRoot = subDir + "/" + pagePath;
-            String modelHref = com.metaobjects.generator.kotlin.apidocs.DocsPaths.INSTANCE
-                    .modelCrossHref(apiPagePathFromDocsRoot, pagePath, modelBaseUrl);
-            put(emitted, pagePath, renderer.renderUnitPage(unit, modelHref));
-        }
-        put(emitted, "README.md", renderer.renderIndex(model, lay));
-        put(emitted, "AGENT-API.md", renderer.renderAgentApi(model));
-        return emitted;
-    }
-
-    // ----- write -------------------------------------------------------------
-
-    /** Write a language surface's pages under {@code outputDirectory/subDir}. */
-    private void writeSurface(String subDir, Map<String, String> emitted) {
-        Path apiRoot = outputDirectory.toPath().resolve(subDir);
-        try {
-            for (Map.Entry<String, String> e : emitted.entrySet()) {
-                Path dest = apiRoot.resolve(e.getKey());
-                // NOT routed through GeneratedFileWriter, deliberately. That guard refuses
-                // any existing file lacking the `GENERATED` marker, and these API pages are
-                // rendered from `templates/api/*.mustache` — none of which emits the token,
-                // and none of which is obliged to. Guarding them made the FIRST run write and
-                // every run after silently refuse, so the docs froze while the build stayed
-                // green and still reported "wrote N api pages".
-                //
-                // The marker floor protects output whose header WE control. Doc pages
-                // rendered from a user-editable template are not that; the guard belongs on
-                // the first-party generators, which were each verified to emit the token.
-                Files.createDirectories(dest.getParent());
-                Files.writeString(dest, e.getValue(), StandardCharsets.UTF_8);
-            }
-        } catch (IOException ex) {
-            throw new UncheckedIOException("metaobjects:docs — failed writing api pages into " + apiRoot, ex);
-        }
-        getLog().info("metaobjects:docs — wrote " + emitted.size() + " api pages into " + apiRoot);
-    }
-
-    /** Insert into the emit map, failing on a duplicate output path (collision guard). */
-    private static void put(Map<String, String> emitted, String path, String content) {
-        if (emitted.containsKey(path)) {
-            throw new IllegalStateException(
-                    "metaobjects:docs — duplicate api page output path: " + path);
-        }
-        emitted.put(path, content);
+    public void execute() throws MojoFailureException {
+        throw new MojoFailureException(REMOVED);
     }
 }
diff --git a/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/EjectSupport.java b/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/EjectSupport.java
index a41064636..1caecc77a 100644
--- a/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/EjectSupport.java
+++ b/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/EjectSupport.java
@@ -68,6 +68,9 @@ public static final class Entry {
         /** Fully-qualified names of the classes eject copies WITH this generator into the
          *  same owned package: the rest of its emit (empty for most generators). */
         public final List<String> with;
+        /** Template references the generator reads from the classpath, which eject copies into
+         *  the adopter's resources (empty for every generator but {@code api-docs}). */
+        public final List<String> resources;
 
         public Entry(Port port, String stableName, String classname, String description, String resourcePath) {
             this(port, stableName, classname, description, resourcePath, List.of());
@@ -80,13 +83,20 @@ public Entry(Port port, String stableName, String classname, String description,
 
         public Entry(Port port, String stableName, String classname, String description,
                      String resourcePath, List<String> runtime, String note, List<String> with) {
+            this(port, stableName, classname, description, resourcePath, runtime, note, with, List.of());
+        }
+
+        public Entry(Port port, String stableName, String classname, String description,
+                     String resourcePath, List<String> runtime, String note, List<String> with,
+                     List<String> resources) {
+            this.resources = List.copyOf(resources);
             this.port = port;
             this.stableName = stableName;
             this.classname = classname;
             this.description = description;
             this.resourcePath = resourcePath;
             this.runtime = List.copyOf(runtime);
-            this.note = note;
+            this.note = API_DOCS.equals(stableName) ? API_DOCS_NOTE : note;
             this.with = List.copyOf(with);
         }
 
@@ -102,14 +112,34 @@ public List<String> sources() {
         /** Classpath resource holding the reference source of {@code source}, one of
          *  {@link #sources()}. */
         public String resourceOf(String source) {
-            return source.equals(classname) ? resourcePath
-                    : GeneratorRegistry.EJECT_RESOURCE_ROOT + simpleNameOf(source) + ".java";
+            if (source.equals(classname)) return resourcePath;
+            String root = port == Port.KOTLIN
+                    ? com.metaobjects.generator.kotlin.GeneratorRegistryKt.EJECT_RESOURCE_ROOT
+                    : GeneratorRegistry.EJECT_RESOURCE_ROOT;
+            return root + simpleNameOf(source) + "." + port.extension;
         }
 
         /** {@link #note} with the owned copy's class name filled in, or {@code null} when
          *  this generator's only wiring is the {@code <classname>} change. */
-        public String wiringNote(String ownedPackage) {
-            return note == null ? null : note.replace("{owned}", ownedPackage + "." + simpleName());
+        public String wiringNote(String basePackage) {
+            return note == null ? null : note.replace("{owned}", ownedClassname(basePackage));
+        }
+
+        /**
+         * The package this generator's copies are written in, given the package eject was asked
+         * for. The {@code api-docs} copies take a subpackage of their port: the Java and the
+         * Kotlin api reference name their page model and path classes alike ({@code ApiUnit},
+         * {@code DocsPaths}, …), and one owned module may hold both. Every other generator's
+         * copies go in {@code basePackage} itself.
+         */
+        public String ownedPackage(String basePackage) {
+            return API_DOCS.equals(stableName)
+                    ? basePackage + "." + API_DOCS_SUBPACKAGE + "." + port.id : basePackage;
+        }
+
+        /** The owned copy's class name: the {@code <generator><classname>} value to wire. */
+        public String ownedClassname(String basePackage) {
+            return ownedPackage(basePackage) + "." + simpleName();
         }
 
         /** The simple class name — also the filename stem the ejected copy is written as. */
@@ -118,6 +148,20 @@ public String simpleName() {
         }
     }
 
+    /** The stable name both ports register their api reference generator under. */
+    public static final String API_DOCS = "api-docs";
+
+    /** What eject prints for {@link #API_DOCS}, on either port. A pom carried over from 8.0 ran
+     *  the api reference through the removed docs goal, so it may hold no entry to change. */
+    private static final String API_DOCS_NOTE =
+            "api-docs: `mvn metaobjects:generate` runs this generator like any other. If your "
+                + "<generators> has no entry for it, add <generator><classname>{owned}</classname>"
+                + "<args><outputDir>your docs directory</outputDir></args></generator>.";
+
+    /** The subpackage of the owned package the {@link #API_DOCS} copies are written under,
+     *  above the one named for their port (see {@link Entry#ownedPackage}). */
+    public static final String API_DOCS_SUBPACKAGE = "apidocs";
+
     /** The simple name of a fully-qualified class name. */
     public static String simpleNameOf(String classname) {
         int dot = classname.lastIndexOf('.');
@@ -141,31 +185,22 @@ public static List<Entry> allEntries() {
         for (GeneratorRegistry.GeneratorInfo info : GeneratorRegistry.list().values()) {
             out.add(new Entry(Port.JAVA, info.stableName(), info.classname(), info.description(),
                     info.ejectResourcePath(), info.ejectRuntime(), info.ejectNote(),
-                    info.ejectWith()));
+                    info.ejectWith(), info.ejectResources()));
         }
         for (Map.Entry<String, GeneratorInfo> e : GeneratorRegistryKt.getGENERATOR_REGISTRY().entrySet()) {
             GeneratorInfo info = e.getValue();
-            // Kotlin generator classes have no separate public "classname" string field —
-            // the registry's factory closure is what constructs them — so the FQN is
-            // derived from the package plus the stable resource filename (both ports name
-            // the ejectable resource after the class's simple name, e.g.
-            // "KotlinNamesGenerator.kt" <-> class KotlinNamesGenerator).
-            String simple = info.getEjectResourcePath() == null ? null
-                    : simpleNameFromResource(info.getEjectResourcePath());
-            String classname = simple == null ? null
-                    : "com.metaobjects.generator.kotlin." + simple;
+            // Kotlin generator classes have no separate public "classname" string field: the
+            // registry's factory closure constructs them, so the FQN is the class it builds
+            // (calling it must not throw — the registry's own contract). The ejectable resource
+            // is named after the class's simple name, e.g. "KotlinNamesGenerator.kt".
+            String classname = info.getEjectResourcePath() == null ? null
+                    : info.getFactory().invoke().getClass().getName();
             out.add(new Entry(Port.KOTLIN, info.getName(), classname, info.getDescription(),
-                    info.getEjectResourcePath()));
+                    info.getEjectResourcePath(), List.of(), null, info.getEjectWith()));
         }
         return out;
     }
 
-    private static String simpleNameFromResource(String resourcePath) {
-        String file = resourcePath.substring(resourcePath.lastIndexOf('/') + 1);
-        int dot = file.lastIndexOf('.');
-        return dot < 0 ? file : file.substring(0, dot);
-    }
-
     /** Only the ejectable entries (non-null {@link Entry#resourcePath}), grouped by stable name. */
     public static Map<String, List<Entry>> ejectableByStableName() {
         Map<String, List<Entry>> byName = new LinkedHashMap<>();
@@ -269,13 +304,14 @@ public static String rewritePackage(String source, String newPackage) {
      * so a bare same-package reference between them already means the copy; an
      * {@code import} of one would still name the packaged class, and the owned generator
      * would go on extending and calling code its owner cannot edit. An import of anything
-     * else is left alone.
+     * else is left alone. Java closes an import with {@code ;} and Kotlin does not; each
+     * keeps its own punctuation.
      */
     public static String rewriteCopiedImports(String source, List<String> copied, String ownedPackage) {
         String out = source;
         for (String classname : copied) {
-            out = out.replaceAll("(?m)^import\\s+" + Pattern.quote(classname) + "\\s*;",
-                    Matcher.quoteReplacement("import " + ownedPackage + "." + simpleNameOf(classname) + ";"));
+            out = out.replaceAll("(?m)^import\\s+" + Pattern.quote(classname) + "(?=\\s*;|[ \\t]*$)",
+                    Matcher.quoteReplacement("import " + ownedPackage + "." + simpleNameOf(classname)));
         }
         return out;
     }
@@ -289,6 +325,32 @@ public static String ownedSource(Entry entry, String reference, String ownedPack
         return rewriteCopiedImports(rewritePackage(reference, ownedPackage), entry.sources(), ownedPackage);
     }
 
+    // ------------------------------------------------------------------------------------
+    // templates — the page text a generator reads from the classpath, handed over with it
+    // ------------------------------------------------------------------------------------
+
+    /** The declaration a copied template provider names its classpath prefix in. */
+    private static final Pattern TEMPLATE_PREFIX_DECL = Pattern.compile(
+            "(?m)^(\\s*private static final String BASE_PREFIX = )\"[\\w/]+\";\\s*$");
+
+    /** The classpath directory the owned templates of the generators in {@code ownedPackage} are
+     *  written under: the package's own path, so no other module's templates can shadow them. */
+    public static String ownedTemplatePrefix(String ownedPackage) {
+        return ownedPackage.replace('.', '/') + "/" + GeneratorRegistry.TEMPLATE_RESOURCE_PREFIX;
+    }
+
+    /** Point a copied template provider's {@code BASE_PREFIX} at {@link #ownedTemplatePrefix}. A
+     *  source with no such declaration is returned unchanged. */
+    public static String rewriteTemplatePrefix(String source, String ownedPackage) {
+        Matcher m = TEMPLATE_PREFIX_DECL.matcher(source);
+        if (!m.find()) return source;
+        String replacement = m.group(1) + "\"" + ownedTemplatePrefix(ownedPackage) + "\";";
+        return new StringBuilder(source).replace(m.start(), m.end(), replacement).toString();
+    }
+
+    /** The extension a template reference resolves with. */
+    public static final String TEMPLATE_EXTENSION = ".md.mustache";
+
     // ------------------------------------------------------------------------------------
     // helper runtime — the source a generator's OUTPUT imports, handed over with it
     // ------------------------------------------------------------------------------------
@@ -439,6 +501,8 @@ private static List<String> normalizedLines(String source) {
             if (t.isEmpty()) continue;
             if (PACKAGE_LINE.matcher(t).matches()) continue;
             if (RUNTIME_PACKAGE_DECL.matcher(t).matches()) continue;
+            if (TEMPLATE_PREFIX_DECL.matcher(t).matches()) continue;
+            if (isImportOfCopiedClass(t)) continue;
             if (SUPPORT_IMPORT.matcher(t).matches()) continue;
             if (t.startsWith(OWNED_RUNTIME_MARKER) || t.startsWith(OWNED_SUPPORT_MARKER)) continue;
             out.add(t);
@@ -446,6 +510,26 @@ private static List<String> normalizedLines(String source) {
         return out;
     }
 
+    private static final Pattern IMPORT_LINE = Pattern.compile("^import\\s+[\\w.]+\\.(\\w+)\\s*;?$");
+
+    /** The simple names of every class eject may copy WITH a generator, across all entries. */
+    private static final class Copied {
+        static final Set<String> SIMPLE_NAMES = allEntries().stream()
+                .flatMap(e -> e.with.stream()).map(EjectSupport::simpleNameOf)
+                .collect(Collectors.toSet());
+    }
+
+    /**
+     * An import of a class eject copies with a generator. Eject points it at the copy when the
+     * copy is written for a generator that copies the class, and a file that two generators copy
+     * (the extractor, with {@code entity} and on its own) is written by whichever came first, so
+     * its imports follow that one: the line is eject's own edit, not drift.
+     */
+    private static boolean isImportOfCopiedClass(String trimmedLine) {
+        Matcher m = IMPORT_LINE.matcher(trimmedLine);
+        return m.matches() && Copied.SIMPLE_NAMES.contains(m.group(1));
+    }
+
     public static Comparison compare(String owned, String reference) {
         List<String> a = normalizedLines(owned);
         List<String> b = normalizedLines(reference);
diff --git a/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/MetaDataEjectMojo.java b/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/MetaDataEjectMojo.java
index 7fdbd5c75..5f251ea37 100644
--- a/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/MetaDataEjectMojo.java
+++ b/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/MetaDataEjectMojo.java
@@ -21,6 +21,8 @@
 import java.util.Map;
 import java.util.Properties;
 import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
 /**
@@ -65,7 +67,8 @@
  * <p><b>What it never does.</b> It never edits the calling project's own {@code pom.xml} —
  * it PRINTS the {@code <module>}, the plugin {@code <dependency>}, and the {@code
  * <generator><classname>} change instead, the same reporting-not-editing stance ADR-0034 §3(c)
- * already rules for the TypeScript command. It never overwrites a file that exists unless
+ * already rules for the TypeScript command. An existing {@code codegen/pom.xml} is the adopter's
+ * too: when it lacks what a port ejected into the module needs, eject prints what to add. It never overwrites a file that exists unless
  * {@code -Dforce=true}. It validates every requested name BEFORE writing anything, so a bad
  * name in a multi-name call ejects nothing rather than half the batch.
  */
@@ -92,7 +95,9 @@ public class MetaDataEjectMojo extends AbstractMojo {
     @Parameter(property = "port")
     String port;
 
-    /** Target package for ejected copies. Defaults to {@code <project.groupId>.codegen}. */
+    /** Target package for ejected copies. Defaults to {@code <project.groupId>.codegen}. The
+     *  {@code api-docs} copies go in a subpackage of it per port (see
+     *  {@link EjectSupport.Entry#ownedPackage}). */
     @Parameter(property = "package")
     String targetPackage;
 
@@ -160,7 +165,6 @@ public void execute() throws MojoExecutionException, MojoFailureException {
                 ? project.getGroupId() + ".codegen" : targetPackage.trim();
 
         Path codegenRoot = project.getBasedir().toPath().resolve(CODEGEN_DIR);
-        Set<EjectSupport.Port> portsTouched = new LinkedHashSet<>();
         List<String> classnameChanges = new ArrayList<>();
 
         List<EjectSupport.Entry> entries = new ArrayList<>();
@@ -178,10 +182,10 @@ public void execute() throws MojoExecutionException, MojoFailureException {
         Set<String> support = new LinkedHashSet<>();
         for (EjectSupport.Resolution r : resolved) {
             EjectSupport.Entry e = r.entry;
-            portsTouched.add(e.port);
 
             String langDir = e.port == EjectSupport.Port.KOTLIN ? "kotlin" : "java";
-            Path pkgDir = codegenRoot.resolve("src/main/" + langDir).resolve(pkg.replace('.', '/'));
+            String ownedPkg = e.ownedPackage(pkg);
+            Path pkgDir = codegenRoot.resolve("src/main/" + langDir).resolve(ownedPkg.replace('.', '/'));
 
             for (String source : e.sources()) {
                 String simpleName = EjectSupport.simpleNameOf(source);
@@ -198,13 +202,16 @@ public void execute() throws MojoExecutionException, MojoFailureException {
                             "Could not read reference source for \"" + e.stableName + "\" at classpath "
                                 + "resource " + resource, ex);
                 }
-                String rewritten = EjectSupport.ownedSource(e, reference, pkg);
+                String rewritten = EjectSupport.ownedSource(e, reference, ownedPkg);
                 if (generator && !e.runtime.isEmpty()) {
                     rewritten = EjectSupport.rewriteRuntimePackage(rewritten, runtimePkg);
                 }
                 if (e.port == EjectSupport.Port.JAVA) {
                     support.addAll(EjectSupport.supportFor(rewritten));
                     rewritten = EjectSupport.rewriteSupportImports(rewritten, pkg);
+                    if (!e.resources.isEmpty()) {
+                        rewritten = EjectSupport.rewriteTemplatePrefix(rewritten, ownedPkg);
+                    }
                 }
 
                 String what = generator ? "\"" + e.stableName + "\""
@@ -212,12 +219,14 @@ public void execute() throws MojoExecutionException, MojoFailureException {
                 reportEject(what, target, rewritten, write(pkgDir, target, rewritten, force));
             }
             classnameChanges.add("  " + e.stableName + ": " + e.classname + "  ->  "
-                    + pkg + "." + e.simpleName());
+                    + e.ownedClassname(pkg));
         }
 
         ejectSupport(support, codegenRoot.resolve("src/main/java").resolve(pkg.replace('.', '/')), pkg);
+        ejectTemplates(resolved, codegenRoot.resolve("src/main/resources"), pkg);
 
-        boolean pomWritten = writeCodegenPomIfNeeded(codegenRoot, pkg, portsTouched);
+        boolean pomWritten = writeCodegenPomIfNeeded(codegenRoot, pkg, portsIn(codegenRoot));
+        reportWhatThePomLacks(codegenRoot);
 
         if (!runtime.isEmpty()) {
             ejectRuntime(runtime, runtimeRoot, runtimePkg);
@@ -234,6 +243,50 @@ public void execute() throws MojoExecutionException, MojoFailureException {
         }
     }
 
+    // ------------------------------------------------------------------------------------
+    // templates
+    // ------------------------------------------------------------------------------------
+
+    /**
+     * Write the templates the ejected generators read from the classpath into the owned module's
+     * resources, under the path of the package each generator's copies are in. The copied template
+     * provider is pointed there ({@link EjectSupport#rewriteTemplatePrefix}), so the owned page
+     * text is what runs.
+     */
+    private void ejectTemplates(List<EjectSupport.Resolution> resolved, Path resourceRoot, String pkg)
+            throws MojoExecutionException {
+        Set<Path> written = new LinkedHashSet<>();
+        for (EjectSupport.Resolution r : resolved) {
+            Path dir = resourceRoot.resolve(EjectSupport.ownedTemplatePrefix(r.entry.ownedPackage(pkg)));
+            for (String ref : r.entry.resources) {
+                Path target = dir.resolve(ref + EjectSupport.TEMPLATE_EXTENSION);
+                if (!written.add(target)) continue;
+                String resource = GeneratorRegistry.EJECT_TEMPLATE_RESOURCE_ROOT + ref + EjectSupport.TEMPLATE_EXTENSION;
+                String content;
+                try {
+                    content = readResource(resource);
+                } catch (IOException ex) {
+                    throw new MojoExecutionException("Could not read reference template \"" + ref
+                            + "\" at classpath resource " + resource, ex);
+                }
+                switch (write(target.getParent(), target, content, force)) {
+                    case CREATED:
+                        getLog().info("Copied template " + ref + " -> " + target
+                                + ". The owned " + r.entry.stableName + " reads this copy; you own it now.");
+                        break;
+                    case REPLACED:
+                        getLog().info("Copied template " + ref + " -> " + target
+                                + ", REPLACING the file that was there (-Dforce=true).");
+                        break;
+                    case PRESERVED:
+                        getLog().info(target + " already exists — " + describeOwned(target, content)
+                                + " Left untouched (-Dforce=true replaces it).");
+                        break;
+                }
+            }
+        }
+    }
+
     // ------------------------------------------------------------------------------------
     // support source
     // ------------------------------------------------------------------------------------
@@ -457,39 +510,69 @@ private boolean writeCodegenPomIfNeeded(Path codegenRoot, String pkg, Set<EjectS
      *  {@code java.version}); an ejected copy compiles against them. */
     static final String JAVA_RELEASE = "21";
 
+    /** The artifact each port's copies compile against. */
+    private static String codegenArtifact(EjectSupport.Port port) {
+        return port == EjectSupport.Port.KOTLIN ? "metaobjects-codegen-kotlin" : "metaobjects-codegen-spring";
+    }
+
+    private static final String KOTLIN_PLUGIN = "kotlin-maven-plugin";
+
+    private static final String KOTLIN_JVM_TARGET =
+            "    <kotlin.compiler.jvmTarget>" + JAVA_RELEASE + "</kotlin.compiler.jvmTarget>\n";
+
+    /** The Kotlin plugin's own source root, for a pom whose {@code <sourceDirectory>} is Java's. */
+    private static final String KOTLIN_SOURCE_DIRS =
+            "        <configuration>\n"
+            + "          <sourceDirs>\n"
+            + "            <sourceDir>${project.basedir}/src/main/kotlin</sourceDir>\n"
+            + "          </sourceDirs>\n"
+            + "        </configuration>\n";
+
+    private String dependency(EjectSupport.Port port) {
+        return "    <dependency>\n"
+            + "      <groupId>com.metaobjects</groupId>\n"
+            + "      <artifactId>" + codegenArtifact(port) + "</artifactId>\n"
+            + "      <version>" + pluginVersion() + "</version>\n"
+            + "    </dependency>\n";
+    }
+
+    /** The Kotlin compiler plugin, with {@code configuration} (possibly empty) inside it. */
+    private static String kotlinPlugin(String configuration) {
+        return "      <plugin>\n"
+            + "        <groupId>org.jetbrains.kotlin</groupId>\n"
+            + "        <artifactId>" + KOTLIN_PLUGIN + "</artifactId>\n"
+            + "        <version>" + kotlin.KotlinVersion.CURRENT + "</version>\n"
+            + configuration
+            + "        <executions>\n"
+            + "          <execution>\n"
+            + "            <id>compile</id>\n"
+            + "            <phase>compile</phase>\n"
+            + "            <goals><goal>compile</goal></goals>\n"
+            + "          </execution>\n"
+            + "        </executions>\n"
+            + "      </plugin>\n";
+    }
+
+    /** The ports the codegen module holds copies of: those with a source root in it. */
+    private static Set<EjectSupport.Port> portsIn(Path codegenRoot) {
+        Set<EjectSupport.Port> out = new LinkedHashSet<>();
+        for (EjectSupport.Port port : EjectSupport.Port.values()) {
+            if (Files.isDirectory(codegenRoot.resolve("src/main/" + port.id))) out.add(port);
+        }
+        return out;
+    }
+
     private String codegenPom(String artifactId, Set<EjectSupport.Port> ports) {
-        String version = pluginVersion();
         StringBuilder deps = new StringBuilder();
-        if (ports.contains(EjectSupport.Port.JAVA)) {
-            deps.append("    <dependency>\n")
-                .append("      <groupId>com.metaobjects</groupId>\n")
-                .append("      <artifactId>metaobjects-codegen-spring</artifactId>\n")
-                .append("      <version>").append(version).append("</version>\n")
-                .append("    </dependency>\n");
-        }
-        if (ports.contains(EjectSupport.Port.KOTLIN)) {
-            deps.append("    <dependency>\n")
-                .append("      <groupId>com.metaobjects</groupId>\n")
-                .append("      <artifactId>metaobjects-codegen-kotlin</artifactId>\n")
-                .append("      <version>").append(version).append("</version>\n")
-                .append("    </dependency>\n");
-        }
+        for (EjectSupport.Port port : ports) deps.append(dependency(port));
+        // A Kotlin-only module makes src/main/kotlin its source root. One that holds Java copies
+        // too keeps Maven's default root for them, and the Kotlin plugin is given its own.
+        boolean java = ports.contains(EjectSupport.Port.JAVA);
         String kotlinPlugin = ports.contains(EjectSupport.Port.KOTLIN)
             ? "  <build>\n"
-              + "    <sourceDirectory>src/main/kotlin</sourceDirectory>\n"
+              + (java ? "" : "    <sourceDirectory>src/main/kotlin</sourceDirectory>\n")
               + "    <plugins>\n"
-              + "      <plugin>\n"
-              + "        <groupId>org.jetbrains.kotlin</groupId>\n"
-              + "        <artifactId>kotlin-maven-plugin</artifactId>\n"
-              + "        <version>" + kotlin.KotlinVersion.CURRENT + "</version>\n"
-              + "        <executions>\n"
-              + "          <execution>\n"
-              + "            <id>compile</id>\n"
-              + "            <phase>compile</phase>\n"
-              + "            <goals><goal>compile</goal></goals>\n"
-              + "          </execution>\n"
-              + "        </executions>\n"
-              + "      </plugin>\n"
+              + kotlinPlugin(java ? KOTLIN_SOURCE_DIRS : "")
               + "    </plugins>\n"
               + "  </build>\n"
             : "";
@@ -508,9 +591,7 @@ private String codegenPom(String artifactId, Set<EjectSupport.Port> ports) {
             // default is -source 8, and Kotlin's default JVM target is older still.
             + "  <properties>\n"
             + "    <maven.compiler.release>" + JAVA_RELEASE + "</maven.compiler.release>\n"
-            + (ports.contains(EjectSupport.Port.KOTLIN)
-                ? "    <kotlin.compiler.jvmTarget>" + JAVA_RELEASE + "</kotlin.compiler.jvmTarget>\n"
-                : "")
+            + (ports.contains(EjectSupport.Port.KOTLIN) ? KOTLIN_JVM_TARGET : "")
             + "  </properties>\n"
             + "  <dependencies>\n"
             + deps
@@ -519,6 +600,53 @@ private String codegenPom(String artifactId, Set<EjectSupport.Port> ports) {
             + "</project>\n";
     }
 
+    private static final Pattern SOURCE_DIRECTORY =
+            Pattern.compile("<sourceDirectory>\\s*([^<]*?)\\s*</sourceDirectory>");
+
+    private static boolean declares(String pom, String artifactId) {
+        return pom.contains("<artifactId>" + artifactId + "</artifactId>");
+    }
+
+    /**
+     * Say what {@code codegen/pom.xml} does not declare that the copies under each port's source
+     * root need. Eject writes that pom for the ports the module holds then and never edits it, so
+     * a port ejected into the module in a later call is left out of the build, and the build passes.
+     */
+    private void reportWhatThePomLacks(Path codegenRoot) throws MojoExecutionException {
+        Path pom = codegenRoot.resolve("pom.xml");
+        String content;
+        try {
+            content = Files.readString(pom, StandardCharsets.UTF_8);
+        } catch (IOException ex) {
+            throw new MojoExecutionException("Could not read " + pom, ex);
+        }
+        for (EjectSupport.Port port : portsIn(codegenRoot)) {
+            String sourceRoot = "src/main/" + port.id;
+            List<String> changes = new ArrayList<>();
+            if (!declares(content, codegenArtifact(port))) {
+                changes.add("  Add to <dependencies>:\n" + dependency(port));
+            }
+            if (port == EjectSupport.Port.KOTLIN && !declares(content, KOTLIN_PLUGIN)) {
+                changes.add("  Add to <properties>:\n" + KOTLIN_JVM_TARGET);
+                changes.add("  Add to <build><plugins>:\n" + kotlinPlugin(KOTLIN_SOURCE_DIRS));
+            }
+            if (port == EjectSupport.Port.JAVA) {
+                Matcher sourceDirectory = SOURCE_DIRECTORY.matcher(content);
+                if (sourceDirectory.find() && !sourceDirectory.group(1).endsWith(sourceRoot)) {
+                    changes.add("  Remove " + sourceDirectory.group() + " from <build>, so that Maven compiles "
+                            + sourceRoot + ", and add to the <plugin> of " + KOTLIN_PLUGIN + ":\n"
+                            + KOTLIN_SOURCE_DIRS);
+                }
+            }
+            if (changes.isEmpty()) continue;
+            getLog().warn(pom + " does not declare what the " + port.id + " copies under " + sourceRoot
+                    + " need to build. It is yours, so eject does not edit it:");
+            for (String change : changes) {
+                for (String line : change.split("\n")) getLog().warn(line);
+            }
+        }
+    }
+
     private static String escape(String s) {
         return s == null ? "" : s.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;");
     }
diff --git a/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/MetaDataVerifyMojo.java b/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/MetaDataVerifyMojo.java
index 53891fb98..c76ce09d7 100644
--- a/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/MetaDataVerifyMojo.java
+++ b/server/java/maven-plugin/src/main/java/com/metaobjects/mojo/MetaDataVerifyMojo.java
@@ -143,6 +143,7 @@ public class MetaDataVerifyMojo extends AbstractMetaDataMojo {
     public void execute() throws MojoExecutionException, MojoFailureException {
         // #233: warm the global registry singletons before verify builds its loader,
         // for the same reason as the generate path (this mojo has its own execute()).
+        refuseRemovedDocsConfiguration("verify");
         com.metaobjects.registry.RegistryBootstrap.warmUpDefaults();
         if (getLoader() == null) {
             throw new MojoExecutionException("No <loader> element was defined");
diff --git a/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/ApiDocsEjectBothPortsTest.java b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/ApiDocsEjectBothPortsTest.java
new file mode 100644
index 000000000..e92d009d8
--- /dev/null
+++ b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/ApiDocsEjectBothPortsTest.java
@@ -0,0 +1,322 @@
+package com.metaobjects.mojo;
+
+import com.metaobjects.generator.Generator;
+import com.metaobjects.loader.InMemoryStringSource;
+import com.metaobjects.loader.LoaderOptions;
+import com.metaobjects.loader.MetaDataLoader;
+import com.tschuchort.compiletesting.KotlinCompilation;
+import com.tschuchort.compiletesting.SourceFile;
+import org.apache.maven.model.Dependency;
+import org.apache.maven.model.Model;
+import org.apache.maven.model.Plugin;
+import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
+import org.apache.maven.plugin.logging.Log;
+import org.apache.maven.project.MavenProject;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.codehaus.plexus.util.xml.Xpp3Dom;
+import org.junit.rules.TemporaryFolder;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+
+import javax.tools.Diagnostic;
+import javax.tools.DiagnosticCollector;
+import javax.tools.JavaCompiler;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.StandardLocation;
+import javax.tools.ToolProvider;
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.Reader;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * A project that documents both languages (an {@code api-docs} {@code <generator>} entry for each)
+ * can own both generators in ONE {@code codegen/} module. The two ports name
+ * their page model and path classes alike ({@code ApiUnit}, {@code ApiSymbol}, {@code FieldShape},
+ * {@code ApiSymbolKind}, {@code DocsPaths}), so the copies have to land where no class is declared
+ * twice.
+ *
+ * <p>Runs the real mojo once per port into one project, then compiles what it wrote with each
+ * language's own compiler. The classname eject prints for each port has to load, from that
+ * compile, as a generator that writes that language's pages.</p>
+ */
+public class ApiDocsEjectBothPortsTest {
+
+    @Rule
+    public TemporaryFolder tempFolder = new TemporaryFolder();
+
+    private Path basedir;
+    private MavenProject project;
+
+    @Before
+    public void setUp() throws IOException {
+        basedir = tempFolder.newFolder("adopter-app").toPath();
+        project = Mockito.mock(MavenProject.class);
+        Mockito.when(project.getBasedir()).thenReturn(basedir.toFile());
+        Mockito.when(project.getGroupId()).thenReturn("com.acme");
+        Mockito.when(project.getArtifactId()).thenReturn("widgets");
+        Mockito.when(project.getVersion()).thenReturn("1.0.0");
+        Mockito.when(project.getDependencies()).thenReturn(List.of());
+    }
+
+    private static final Pattern CLASSNAME_CHANGE = Pattern.compile("^\\s*api-docs: \\S+\\s+->\\s+(\\S+)$");
+
+    /** Eject {@code api-docs} for one port, and return the log eject wrote to. */
+    private Log eject(String port) throws Exception {
+        return eject("api-docs", port, false);
+    }
+
+    private Log eject(String names, String port, boolean force) throws Exception {
+        MetaDataEjectMojo mojo = new MetaDataEjectMojo();
+        mojo.project = project;
+        mojo.names = names;
+        mojo.port = port;
+        mojo.force = force;
+        Log log = Mockito.mock(Log.class);
+        mojo.setLog(log);
+        mojo.execute();
+        return log;
+    }
+
+    private Model codegenPom() throws Exception {
+        try (Reader in = Files.newBufferedReader(basedir.resolve("codegen/pom.xml"), StandardCharsets.UTF_8)) {
+            return new MavenXpp3Reader().read(in);
+        }
+    }
+
+    /**
+     * The pom builds both ports' copies: it depends on both codegen artifacts, leaves Maven's
+     * source root at its default ({@code src/main/java}, which javac compiles), and gives the
+     * Kotlin plugin {@code src/main/kotlin} itself. Read through Maven's own model reader.
+     *
+     * <p>The module is not built by Maven here: its dependencies are this reactor's artifacts,
+     * which no repository holds while these tests run. Both source trees are compiled, by each
+     * language's compiler, in {@link #bothPortsEjectedIntoOneModuleCompileAndDeclareNoClassTwice}.</p>
+     */
+    private void assertPomBuildsBothPorts() throws Exception {
+        Model pom = codegenPom();
+        Set<String> dependencies = pom.getDependencies().stream()
+                .map(Dependency::getArtifactId).collect(Collectors.toCollection(TreeSet::new));
+        assertEquals(Set.of("metaobjects-codegen-kotlin", "metaobjects-codegen-spring"), dependencies);
+        assertNull("a source root set here replaces Maven's default, src/main/java",
+                pom.getBuild().getSourceDirectory());
+        Plugin kotlin = pom.getBuild().getPlugins().stream()
+                .filter(p -> p.getArtifactId().equals("kotlin-maven-plugin")).findFirst().orElseThrow();
+        Xpp3Dom sourceDirs = ((Xpp3Dom) kotlin.getConfiguration()).getChild("sourceDirs");
+        assertEquals(1, sourceDirs.getChildCount());
+        assertEquals("${project.basedir}/src/main/kotlin", sourceDirs.getChild(0).getValue());
+    }
+
+    /** Eject {@code api-docs} for one port, and return the owned classname eject printed for it. */
+    private String ejectApiDocs(String port) throws Exception {
+        ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
+        Mockito.verify(eject(port), Mockito.atLeastOnce()).info(captor.capture());
+        List<String> printed = new ArrayList<>();
+        for (CharSequence line : captor.getAllValues()) {
+            Matcher m = CLASSNAME_CHANGE.matcher(line);
+            if (m.matches()) printed.add(m.group(1));
+        }
+        assertEquals(port + ": eject prints one <classname> change for api-docs", 1, printed.size());
+        // The wiring note names the same class for the <generator> entry to add.
+        String owned = printed.get(0);
+        assertTrue(port + ": no wiring note names " + owned, captor.getAllValues().stream()
+                .anyMatch(line -> line.toString().contains("<classname>" + owned + "</classname>")));
+        return owned;
+    }
+
+    /** Everything eject warned about, one printed line per element. */
+    private static List<String> warnings(Log log) {
+        ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
+        Mockito.verify(log, Mockito.atLeast(0)).warn(captor.capture());
+        return captor.getAllValues().stream().map(line -> line.toString().strip()).collect(Collectors.toList());
+    }
+
+    private static List<File> sourcesUnder(Path root, String extension) throws IOException {
+        try (Stream<Path> s = Files.walk(root)) {
+            return s.filter(p -> p.toString().endsWith(extension)).map(Path::toFile).collect(Collectors.toList());
+        }
+    }
+
+    /** Every class file under {@code classes}, as a path relative to it: one per declared class. */
+    private static Set<String> declared(Path classes) throws IOException {
+        try (Stream<Path> s = Files.walk(classes)) {
+            return s.filter(p -> p.toString().endsWith(".class"))
+                    .map(p -> classes.relativize(p).toString().replace(File.separatorChar, '/'))
+                    .collect(Collectors.toCollection(TreeSet::new));
+        }
+    }
+
+    private Path compileJava(Path sourceRoot) throws IOException {
+        List<File> sources = sourcesUnder(sourceRoot, ".java");
+        assertFalse("eject wrote no Java source", sources.isEmpty());
+        Path classes = tempFolder.newFolder("java-classes").toPath();
+        JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
+        DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
+        try (StandardJavaFileManager fm = javac.getStandardFileManager(diagnostics, null, StandardCharsets.UTF_8)) {
+            fm.setLocation(StandardLocation.CLASS_OUTPUT, List.of(classes.toFile()));
+            javac.getTask(null, fm, diagnostics,
+                    List.of("-proc:none", "-classpath", System.getProperty("java.class.path")),
+                    null, fm.getJavaFileObjectsFromFiles(sources)).call();
+        }
+        String errors = diagnostics.getDiagnostics().stream()
+                .filter(d -> d.getKind() == Diagnostic.Kind.ERROR).map(d -> "  " + d).collect(Collectors.joining("\n"));
+        assertEquals("the Java api-docs copy does not compile", "", errors);
+        return classes;
+    }
+
+    private KotlinCompilation.Result compileKotlin(Path sourceRoot) throws IOException {
+        List<SourceFile> sources = new ArrayList<>();
+        for (File file : sourcesUnder(sourceRoot, ".kt")) sources.add(SourceFile.Companion.fromPath(file, false));
+        assertFalse("eject wrote no Kotlin source", sources.isEmpty());
+        KotlinCompilation compilation = new KotlinCompilation();
+        compilation.setSources(sources);
+        compilation.setInheritClassPath(true);
+        compilation.setMessageOutputStream(OutputStream.nullOutputStream());
+        KotlinCompilation.Result result = compilation.compile();
+        assertEquals("the Kotlin api-docs copy does not compile:\n" + result.getMessages(),
+                KotlinCompilation.ExitCode.OK, result.getExitCode());
+        return result;
+    }
+
+    private static final String MODEL = "{ \"metadata.root\": { \"package\": \"acme::shop\", \"children\": ["
+            + " { \"object.value\": { \"name\": \"Money\", \"children\": ["
+            + " { \"field.string\": { \"name\": \"code\" } } ]}} ]}}";
+
+    /** Run the owned generator the way a {@code <generator>} entry does, and require the pages of
+     *  {@code language} and nothing outside them. */
+    private void assertWritesTheApiReferenceOf(String language, String classname, ClassLoader loader)
+            throws Exception {
+        Generator generator = (Generator) Class.forName(classname, true, loader)
+                .getDeclaredConstructor().newInstance();
+        MetaDataLoader model = new MetaDataLoader(
+                LoaderOptions.create(false, false, true), MetaDataLoader.SUBTYPE_MANUAL, "owned-api-docs-" + language);
+        model.init();
+        model.load(List.of(new InMemoryStringSource(MODEL, "owned-api-docs/meta.json")));
+        Path out = tempFolder.newFolder("docs-" + language).toPath();
+        generator.setArgs(Map.of("outputDir", out.toString()));
+        generator.execute(model);
+
+        Set<String> written = new TreeSet<>();
+        try (Stream<Path> s = Files.walk(out)) {
+            s.filter(Files::isRegularFile).forEach(p -> written.add(out.relativize(p).toString()
+                    .replace(File.separatorChar, '/')));
+        }
+        assertEquals(classname, Set.of("api/" + language + "/AGENT-API.md", "api/" + language + "/Money.md",
+                "api/" + language + "/README.md"), written);
+    }
+
+    // The pom eject writes builds every port the module holds then. It is never edited afterwards,
+    // so a port ejected later is left out of the build unless eject says what the pom has to gain. What each
+    // port needs is fixed by Maven and by where eject writes: its codegen artifact, a compiler for
+    // its language, and its directory as a source root.
+
+    @Test
+    public void aPomWrittenForThePortBeingEjectedDrawsNoWarning() throws Exception {
+        assertEquals(List.of(), warnings(eject("java")));
+        assertEquals("the same port again, into the pom written for it", List.of(), warnings(eject("java")));
+    }
+
+    @Test
+    public void oneCallThatNamesBothPortsWritesAPomThatBuildsBothAndWarnsOfNothing() throws Exception {
+        // A Java-only name beside a Kotlin-only one: no -Dport, and one call holds both ports.
+        Log log = eject("html-docs,exposed-table", null, false);
+
+        assertFalse(sourcesUnder(basedir.resolve("codegen/src/main/java"), ".java").isEmpty());
+        assertFalse(sourcesUnder(basedir.resolve("codegen/src/main/kotlin"), ".kt").isEmpty());
+        assertPomBuildsBothPorts();
+        assertEquals(List.of(), warnings(log));
+    }
+
+    @Test
+    public void aForcedEjectRewritesThePomForEveryPortTheModuleHolds() throws Exception {
+        eject("java");
+        eject("kotlin");
+
+        Log log = eject("api-docs", "kotlin", true);
+
+        assertPomBuildsBothPorts();
+        assertEquals(List.of(), warnings(log));
+    }
+
+    @Test
+    public void kotlinEjectedIntoAJavaModulePrintsTheDependencyAndTheCompilerItsPomLacks() throws Exception {
+        eject("java");
+        Path pom = basedir.resolve("codegen/pom.xml");
+        String before = Files.readString(pom, StandardCharsets.UTF_8);
+
+        List<String> warned = warnings(eject("kotlin"));
+
+        assertEquals("eject never edits an existing pom", before, Files.readString(pom, StandardCharsets.UTF_8));
+        assertTrue(warned.toString(), warned.contains("<artifactId>metaobjects-codegen-kotlin</artifactId>"));
+        assertTrue(warned.toString(), warned.contains("<artifactId>kotlin-maven-plugin</artifactId>"));
+        // The plugin is given the Kotlin root itself: the pom's own source root stays Java's.
+        assertTrue(warned.toString(), warned.contains("<sourceDir>${project.basedir}/src/main/kotlin</sourceDir>"));
+        assertTrue(warned.toString(), warned.contains("<kotlin.compiler.jvmTarget>21</kotlin.compiler.jvmTarget>"));
+        // The Java port's needs are met by the pom written for it.
+        assertFalse(warned.toString(), warned.contains("<artifactId>metaobjects-codegen-spring</artifactId>"));
+        assertFalse(warned.toString(), warned.stream().anyMatch(line -> line.contains("<sourceDirectory>")));
+    }
+
+    @Test
+    public void javaEjectedIntoAKotlinModulePrintsTheDependencyAndTheSourceRootItsPomLacks() throws Exception {
+        eject("kotlin");
+        Path pom = basedir.resolve("codegen/pom.xml");
+        String before = Files.readString(pom, StandardCharsets.UTF_8);
+
+        List<String> warned = warnings(eject("java"));
+
+        assertEquals("eject never edits an existing pom", before, Files.readString(pom, StandardCharsets.UTF_8));
+        assertTrue(warned.toString(), warned.contains("<artifactId>metaobjects-codegen-spring</artifactId>"));
+        // The Kotlin pom's source root is src/main/kotlin, which leaves src/main/java uncompiled.
+        assertTrue(warned.toString(), warned.stream().anyMatch(line ->
+                line.startsWith("Remove <sourceDirectory>src/main/kotlin</sourceDirectory>")
+                        && line.contains("src/main/java")));
+        assertTrue(warned.toString(), warned.contains("<sourceDir>${project.basedir}/src/main/kotlin</sourceDir>"));
+        // The Kotlin port's needs are met by the pom written for it.
+        assertFalse(warned.toString(), warned.contains("<artifactId>metaobjects-codegen-kotlin</artifactId>"));
+        assertFalse(warned.toString(), warned.contains("<artifactId>kotlin-maven-plugin</artifactId>"));
+    }
+
+    @Test
+    public void bothPortsEjectedIntoOneModuleCompileAndDeclareNoClassTwice() throws Exception {
+        String ownedJava = ejectApiDocs("java");
+        String ownedKotlin = ejectApiDocs("kotlin");
+
+        Path codegen = basedir.resolve("codegen");
+        Path javaClasses = compileJava(codegen.resolve("src/main/java"));
+        KotlinCompilation.Result kotlin = compileKotlin(codegen.resolve("src/main/kotlin"));
+
+        // One module has one class output: a class both languages declare is a build failure.
+        Set<String> twice = declared(javaClasses);
+        twice.retainAll(declared(kotlin.getOutputDirectory().toPath()));
+        assertEquals("classes the Java and the Kotlin api-docs copies both declare", Set.of(), twice);
+
+        URL[] javaUrls = {javaClasses.toUri().toURL(), codegen.resolve("src/main/resources/").toUri().toURL()};
+        try (URLClassLoader java = new URLClassLoader(javaUrls, getClass().getClassLoader())) {
+            assertWritesTheApiReferenceOf("java", ownedJava, java);
+        }
+        assertWritesTheApiReferenceOf("kotlin", ownedKotlin, kotlin.getClassLoader());
+    }
+}
diff --git a/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/ApiDocsGeneratorEntryTest.java b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/ApiDocsGeneratorEntryTest.java
new file mode 100644
index 000000000..434a2374b
--- /dev/null
+++ b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/ApiDocsGeneratorEntryTest.java
@@ -0,0 +1,162 @@
+package com.metaobjects.mojo;
+
+import com.metaobjects.generator.GeneratorException;
+import com.metaobjects.generator.apidocs.JavaApiDocsGenerator;
+import com.metaobjects.generator.kotlin.apidocs.KotlinApiDocsGenerator;
+import org.apache.maven.plugin.MojoFailureException;
+import org.apache.maven.plugin.testing.MojoRule;
+import org.codehaus.plexus.PlexusTestCase;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import java.io.File;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * The api reference is a {@code <generator>} entry like any other (ADR-0034 Amendment 9):
+ * {@code metaobjects:generate} writes it for each language the list names, from the options
+ * in that entry's {@code <args>}, and {@code metaobjects:verify} checks its pages with the
+ * rest of the list.
+ */
+public class ApiDocsGeneratorEntryTest {
+
+    private static final String JAVA_DOCS = JavaApiDocsGenerator.class.getName();
+    private static final String KOTLIN_DOCS = KotlinApiDocsGenerator.class.getName();
+
+    @Rule
+    public MojoRule rule = new MojoRule();
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    private static File pom() {
+        return new File(PlexusTestCase.getBasedir(), "src/test/resources/mojo/pom-api-docs.xml");
+    }
+
+    private static Path docs() {
+        return new File(PlexusTestCase.getBasedir(), "target/api-docs-test/docs").toPath();
+    }
+
+    @Test
+    public void theGenerateGoalWritesTheApiReferenceOfEachLanguageTheListNames() throws Exception {
+        ((MetaDataGeneratorMojo) rule.lookupMojo("generate", pom())).execute();
+
+        // The Java entry sets every option: <apiSubDir>, <layout>package (the Basket entity of
+        // package simple::fruitbasket lands under its package folder), <projectName> and
+        // <modelBaseUrl>.
+        Path java = docs().resolve("reference/java");
+        Path basket = java.resolve("simple/fruitbasket/Basket.md");
+        assertTrue("expected entity api page at " + basket, Files.exists(basket));
+        assertTrue("expected index README.md", Files.exists(java.resolve("README.md")));
+        String page = Files.readString(basket);
+        assertTrue(page, page.contains("```java"));
+        assertTrue("the model link is written against <modelBaseUrl>: " + page,
+                page.contains("**Model / metadata:**") && page.contains("https://docs.example.test/model/"));
+        String agent = Files.readString(java.resolve("AGENT-API.md"));
+        assertTrue("the agent page carries <projectName>: " + agent, agent.contains("fruit-shop"));
+
+        // The Kotlin entry takes every default: api/kotlin, flat layout.
+        Path kotlin = docs().resolve("api/kotlin");
+        assertTrue(Files.exists(kotlin.resolve("README.md")));
+        assertTrue(Files.exists(kotlin.resolve("AGENT-API.md")));
+        String kotlinPage = Files.readString(kotlin.resolve("Basket.md"));
+        assertTrue(kotlinPage, kotlinPage.contains("```kotlin"));
+        assertTrue(kotlinPage, kotlinPage.contains("**Model / metadata:**"));
+    }
+
+    @Test
+    public void regeneratingUpdatesThePages_itDoesNotFreezeAfterTheFirstRun() throws Exception {
+        // A DO-NOT-EDIT artifact that stops updating is the worst kind of stale: the
+        // command still reports success. This fires because the marker write-guard was
+        // briefly applied here, and API pages are rendered from user-editable Mustache
+        // templates that emit no marker — so run 1 wrote, run 2 refused, and the docs
+        // silently froze while the build stayed green. Only a second run distinguishes
+        // "writes" from "keeps writing".
+        Path basket = docs().resolve("reference/java/simple/fruitbasket/Basket.md");
+
+        ((MetaDataGeneratorMojo) rule.lookupMojo("generate", pom())).execute();
+        assertTrue("first run should emit the page", Files.exists(basket));
+
+        // Stand in for "the model changed": clobber the page, then regenerate. A second
+        // run that refuses leaves the sentinel in place.
+        Files.writeString(basket, "STALE SENTINEL\n");
+        ((MetaDataGeneratorMojo) rule.lookupMojo("generate", pom())).execute();
+
+        String after = Files.readString(basket);
+        assertFalse("second run must rewrite the page, not refuse it — a frozen "
+                + "DO-NOT-EDIT artifact reports success while going stale",
+                after.contains("STALE SENTINEL"));
+        assertTrue("regenerated page should carry its normal content",
+                after.contains("**Model / metadata:**"));
+    }
+
+    // ------------------------------------------------------------------------------------
+    // verify covers the pages, as it covers every other entry's output
+    // ------------------------------------------------------------------------------------
+
+    private void configure(AbstractMetaDataMojo mojo, GeneratorParam... generators) {
+        mojo.setLoader(LoaderParam.builder("api-docs-entry-test")
+                .withClassname("com.metaobjects.loader.MetaDataLoader")
+                .withSourceDir("./src/test/resources")
+                .withSource("mojo/verify-test-metadata.json")
+                .build());
+        mojo.setGenerators(new ArrayList<>(List.of(generators)));
+        mojo.setGlobals(Collections.emptyMap());
+    }
+
+    private static GeneratorParam entry(String classname, Path outputDir, String... args) {
+        GeneratorParam.Builder b = GeneratorParam.builder(classname).withArg("outputDir", outputDir.toString());
+        for (int i = 0; i < args.length; i += 2) b.withArg(args[i], args[i + 1]);
+        return b.build();
+    }
+
+    @Test
+    public void theVerifyGoalChecksThePagesOfBothLanguagesInOneDirectory() throws Exception {
+        Path committed = tmp.newFolder("docs").toPath();
+        MetaDataGeneratorMojo generate = new MetaDataGeneratorMojo();
+        configure(generate, entry(JAVA_DOCS, committed), entry(KOTLIN_DOCS, committed));
+        generate.execute();
+
+        MetaDataVerifyMojo inSync = new MetaDataVerifyMojo();
+        configure(inSync, entry(JAVA_DOCS, committed), entry(KOTLIN_DOCS, committed));
+        inSync.execute();
+
+        Path page = committed.resolve("api/kotlin/Widget.md");
+        Files.writeString(page, Files.readString(page) + "\nedited by hand\n", StandardCharsets.UTF_8);
+        MetaDataVerifyMojo drifted = new MetaDataVerifyMojo();
+        configure(drifted, entry(JAVA_DOCS, committed), entry(KOTLIN_DOCS, committed));
+        try {
+            drifted.execute();
+            fail("expected the edited page to read as drift");
+        } catch (MojoFailureException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("[content-differs] " + page));
+            assertFalse("only the edited page drifted: " + e.getMessage(), e.getMessage().contains("api/java"));
+        }
+    }
+
+    @Test
+    public void aLayoutThatNamesNoLayoutIsRefusedOnBothPorts() throws Exception {
+        for (String classname : List.of(JAVA_DOCS, KOTLIN_DOCS)) {
+            MetaDataGeneratorMojo generate = new MetaDataGeneratorMojo();
+            Path out = tmp.newFolder().toPath();
+            configure(generate, entry(classname, out, "layout", "packaged"));
+            try {
+                generate.execute();
+                fail(classname + ": expected <layout>packaged</layout> to be refused");
+            } catch (GeneratorException e) {
+                assertTrue(e.getMessage(), e.getMessage().contains(
+                        "api-docs: <layout> must be flat or package (got \"packaged\")"));
+            }
+        }
+    }
+}
diff --git a/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/DeclaresNothingWritesNothingTest.java b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/DeclaresNothingWritesNothingTest.java
new file mode 100644
index 000000000..28974e155
--- /dev/null
+++ b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/DeclaresNothingWritesNothingTest.java
@@ -0,0 +1,108 @@
+package com.metaobjects.mojo;
+
+import com.metaobjects.generator.direct.object.javacode.JavaObjectCodeGenerator;
+import com.metaobjects.generator.kotlin.KotlinEntityGenerator;
+import org.apache.maven.project.MavenProject;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.mockito.Mockito;
+
+import java.io.File;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Nothing is generated that the pom does not declare (ADR-0034 Amendment 9).
+ *
+ * <p>The rule has two halves, and each port is held to both. A pom whose {@code <generators>}
+ * is empty or absent writes zero files: no default generator set, no documentation. And a
+ * pom that lists one generator gets that generator's files and no other's: the Java
+ * {@code entity} wrote a {@code <Name>Extractor} beside each class through 8.0, and the api
+ * reference was written by a goal of its own.</p>
+ */
+public class DeclaresNothingWritesNothingTest {
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    private Path module;
+
+    @Before
+    public void aModuleOfItsOwn() throws Exception {
+        module = tmp.newFolder("module").toPath();
+    }
+
+    /** A generate goal in a module of its own, so every file the run writes is under it. */
+    private MetaDataGeneratorMojo generateGoal(List<GeneratorParam> generators) {
+        MetaDataGeneratorMojo mojo = new MetaDataGeneratorMojo();
+        MavenProject project = Mockito.mock(MavenProject.class);
+        Mockito.when(project.getBasedir()).thenReturn(module.toFile());
+        mojo.project = project;
+        mojo.setLoader(LoaderParam.builder("declares-nothing-test")
+                .withClassname("com.metaobjects.loader.MetaDataLoader")
+                .withSourceDir(new File("src/test/resources").getAbsolutePath())
+                .withSource("mojo/verify-test-metadata.json")
+                .build());
+        mojo.setGenerators(generators);
+        mojo.setGlobals(Collections.emptyMap());
+        return mojo;
+    }
+
+    private List<String> written() throws Exception {
+        try (Stream<Path> s = Files.walk(module)) {
+            return s.filter(Files::isRegularFile)
+                    .map(p -> module.relativize(p).toString().replace(File.separatorChar, '/'))
+                    .sorted().collect(Collectors.toList());
+        }
+    }
+
+    @Test
+    public void aPomWithNoGeneratorsElementWritesZeroFiles() throws Exception {
+        generateGoal(null).execute();
+        assertEquals(List.of(), written());
+    }
+
+    @Test
+    public void aPomWithAnEmptyGeneratorsListWritesZeroFiles() throws Exception {
+        generateGoal(new ArrayList<>()).execute();
+        assertEquals(List.of(), written());
+    }
+
+    @Test
+    public void java_aPomThatListsOnlyEntityGetsItsClassesAndNoExtractorOrApiReference() throws Exception {
+        generateGoal(new ArrayList<>(List.of(GeneratorParam.builder(JavaObjectCodeGenerator.class.getName())
+                .withArg("outputDir", "generated")
+                .withArg("type", "class")
+                .withArg("flavor", "pojoAware")
+                .build()))).execute();
+
+        assertEquals(List.of(
+                "generated/META-INF/services/com.metaobjects.registry.ObjectClassBindingProvider",
+                "generated/com/metaobjects/generated/GeneratedObjectClassBindingProvider.java",
+                "generated/verify/demo/Gadget.java",
+                "generated/verify/demo/Widget.java"), written());
+    }
+
+    @Test
+    public void kotlin_aPomThatListsOnlyEntityGetsItsFilesAndNoApiReference() throws Exception {
+        generateGoal(new ArrayList<>(List.of(GeneratorParam.builder(KotlinEntityGenerator.class.getName())
+                .withArg("outputDir", "generated")
+                .build()))).execute();
+
+        List<String> written = written();
+        assertFalse("the listed generator wrote nothing", written.isEmpty());
+        assertTrue("a file the entry did not declare: " + written,
+                written.stream().allMatch(f -> f.startsWith("generated/verify/demo/") && f.endsWith(".kt")));
+    }
+}
diff --git a/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/DocsMojoTest.java b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/DocsMojoTest.java
deleted file mode 100644
index 889d35b82..000000000
--- a/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/DocsMojoTest.java
+++ /dev/null
@@ -1,106 +0,0 @@
-package com.metaobjects.mojo;
-
-import org.apache.maven.plugin.testing.MojoRule;
-import org.codehaus.plexus.PlexusTestCase;
-import org.junit.Rule;
-import org.junit.Test;
-
-import java.io.File;
-import java.nio.file.Files;
-import java.nio.file.Path;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-/**
- * Tests the {@code metaobjects:docs} goal — that it loads metadata from the
- * {@code <loader>} config, builds the {@code JavaApiModel}, renders it via
- * {@code JavaApiDocsRenderer}, and writes the Java api surface into the configured
- * {@code <apiSubDir>} with a model cross-link on each unit page (the SP-1
- * {@code apiSurfaces} {@code api/java} surface).
- */
-public class DocsMojoTest {
-
-    @Rule
-    public MojoRule rule = new MojoRule();
-
-    @Test
-    public void emitsTheJavaApiSurface() throws Exception {
-        File pom = new File(PlexusTestCase.getBasedir(), "src/test/resources/mojo/pom-docs.xml");
-
-        DocsMojo mojo = (DocsMojo) rule.lookupMojo("docs", pom);
-        assertNotNull(mojo);
-        mojo.execute();
-
-        // <outputDirectory> (target/docs-mojo-test/docs) / <apiSubDir> (api/java).
-        Path apiBase = new File(PlexusTestCase.getBasedir(),
-                "target/docs-mojo-test/docs/api/java").toPath();
-
-        // The concrete Basket entity (package simple::fruitbasket → simple/fruitbasket)
-        // produces an api page under its package folder for the package layout.
-        Path basketPage = apiBase.resolve("simple/fruitbasket/Basket.md");
-        assertTrue("expected entity api page at " + basketPage, Files.exists(basketPage));
-        assertTrue("expected index README.md", Files.exists(apiBase.resolve("README.md")));
-        assertTrue("expected condensed AGENT-API.md", Files.exists(apiBase.resolve("AGENT-API.md")));
-
-        String page = Files.readString(basketPage);
-        assertTrue("unit page emits the model/metadata cross-link",
-                page.contains("**Model / metadata:**"));
-        assertTrue("unit page emits a java code fence", page.contains("```java"));
-    }
-
-    @Test
-    public void regeneratingUpdatesThePages_itDoesNotFreezeAfterTheFirstRun() throws Exception {
-        // A DO-NOT-EDIT artifact that stops updating is the worst kind of stale: the
-        // command still reports success. This fires because the marker write-guard was
-        // briefly applied here, and API pages are rendered from user-editable Mustache
-        // templates that emit no marker — so run 1 wrote, run 2 refused, and the docs
-        // silently froze while the build stayed green.
-        //
-        // The existing tests could not see it: each runs the mojo exactly ONCE. Only a
-        // second run distinguishes "writes" from "keeps writing".
-        File pom = new File(PlexusTestCase.getBasedir(), "src/test/resources/mojo/pom-docs.xml");
-        Path apiBase = new File(PlexusTestCase.getBasedir(),
-                "target/docs-mojo-test/docs/api/java").toPath();
-        Path basketPage = apiBase.resolve("simple/fruitbasket/Basket.md");
-
-        ((DocsMojo) rule.lookupMojo("docs", pom)).execute();
-        assertTrue("first run should emit the page", Files.exists(basketPage));
-
-        // Stand in for "the model changed": clobber the page, then regenerate. A second
-        // run that refuses leaves the sentinel in place.
-        Files.writeString(basketPage, "STALE SENTINEL\n");
-        ((DocsMojo) rule.lookupMojo("docs", pom)).execute();
-
-        String after = Files.readString(basketPage);
-        assertFalse("second run must rewrite the page, not refuse it — a frozen "
-                + "DO-NOT-EDIT artifact reports success while going stale",
-                after.contains("STALE SENTINEL"));
-        assertTrue("regenerated page should carry its normal content",
-                after.contains("**Model / metadata:**"));
-    }
-
-    @Test
-    public void emitsTheKotlinApiSurface() throws Exception {
-        File pom = new File(PlexusTestCase.getBasedir(), "src/test/resources/mojo/pom-docs-kotlin.xml");
-
-        DocsMojo mojo = (DocsMojo) rule.lookupMojo("docs", pom);
-        assertNotNull(mojo);
-        mojo.execute();
-
-        // <language>kotlin</language> with no explicit <apiSubDir> → api/kotlin.
-        Path apiBase = new File(PlexusTestCase.getBasedir(),
-                "target/docs-mojo-test-kotlin/docs/api/kotlin").toPath();
-
-        Path basketPage = apiBase.resolve("simple/fruitbasket/Basket.md");
-        assertTrue("expected entity api page at " + basketPage, Files.exists(basketPage));
-        assertTrue("expected index README.md", Files.exists(apiBase.resolve("README.md")));
-        assertTrue("expected condensed AGENT-API.md", Files.exists(apiBase.resolve("AGENT-API.md")));
-
-        String page = Files.readString(basketPage);
-        assertTrue("unit page emits the model/metadata cross-link",
-                page.contains("**Model / metadata:**"));
-        assertTrue("unit page emits a kotlin code fence", page.contains("```kotlin"));
-    }
-}
diff --git a/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EjectContractTest.java b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EjectContractTest.java
index 9d843c221..f7c99a10e 100644
--- a/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EjectContractTest.java
+++ b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EjectContractTest.java
@@ -7,6 +7,8 @@
 import com.metaobjects.generator.Generator;
 import com.metaobjects.generator.GeneratorRegistry;
 import com.metaobjects.generator.ProjectClassLoaderAware;
+import com.metaobjects.generator.direct.DirectGeneratorBase;
+import com.metaobjects.generator.direct.MultiFileDirectGeneratorBase;
 import com.metaobjects.loader.DirectorySource;
 import com.metaobjects.loader.LoaderOptions;
 import com.metaobjects.loader.MetaDataLoader;
@@ -314,6 +316,9 @@ public void completenessTheShippedReferenceSourcesAreExactlyTheOnesTheRegistryNa
             if (e.resourcePath == null) continue;
             for (String classname : e.sources()) named.add(root + EjectSupport.simpleNameOf(classname) + ".java");
             for (String runtime : e.runtime) named.add(GeneratorRegistry.EJECT_RUNTIME_RESOURCE_ROOT + runtime + ".java");
+            for (String template : e.resources) {
+                named.add(GeneratorRegistry.EJECT_TEMPLATE_RESOURCE_ROOT + template + EjectSupport.TEMPLATE_EXTENSION);
+            }
         }
         for (String support : GeneratorRegistry.EJECT_SUPPORT) {
             named.add(GeneratorRegistry.EJECT_SUPPORT_RESOURCE_ROOT + support + ".java");
@@ -506,6 +511,11 @@ private Map<String, String> run(Generator generator, Corpus corpus, MetaDataLoad
         args.put("testPackage", "com.example.requirements");
         args.put("witnessClass", "com.example.Witnesses");
         args.put("warnUncovered", "false");
+        // The file the single-file generators write: the docs, diagram and schema generators. The
+        // per-object ones read this arg as the name of a file to merge into, so they must not get it.
+        if (generator instanceof DirectGeneratorBase && !(generator instanceof MultiFileDirectGeneratorBase)) {
+            args.put("outputFilename", "contract.out");
+        }
         // The one difference an owned copy's output is allowed: it imports the helper runtime
         // the adopter owns. The packaged generator is pointed at the same package to compare.
         if (packaged) args.put("runtimePackage", OWNED_RUNTIME_PACKAGE);
@@ -526,13 +536,17 @@ private Map<String, String> run(Generator generator, Corpus corpus, MetaDataLoad
     public void depthAnUnchangedOwnedCopyEmitsWhatThePackagedGeneratorEmits() throws Exception {
         List<String> silent = new ArrayList<>();
         for (EjectSupport.Entry e : ejectable()) {
-            Path classes = compileAlone(e.stableName, ejectAlone(e.stableName));
+            Path projectDir = ejectAlone(e.stableName);
+            Path classes = compileAlone(e.stableName, projectDir);
             int emitted = 0;
-            try (URLClassLoader cl = new URLClassLoader(new URL[]{classes.toUri().toURL()}, getClass().getClassLoader())) {
+            // The owned classes, and the resources eject wrote beside them: a generator that reads
+            // its page text from the classpath reads the owned copy, whose path no package shares.
+            URL[] ownedUrls = {classes.toUri().toURL(), projectDir.resolve("codegen/src/main/resources/").toUri().toURL()};
+            try (URLClassLoader cl = new URLClassLoader(ownedUrls, getClass().getClassLoader())) {
                 for (Corpus corpus : CORPORA) {
                     String where = e.stableName + " over " + corpus.label;
                     Generator packaged = (Generator) Class.forName(e.classname).getDeclaredConstructor().newInstance();
-                    Generator owned = (Generator) Class.forName(OWNED_PACKAGE + "." + e.simpleName(), true, cl)
+                    Generator owned = (Generator) Class.forName(e.ownedClassname(OWNED_PACKAGE), true, cl)
                             .getDeclaredConstructor().newInstance();
                     Map<String, String> a = run(packaged, corpus, corpus.loader(), true);
                     Map<String, String> b = run(owned, corpus, corpus.loader(), false);
diff --git a/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EjectRuntimeRoundTripTest.java b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EjectRuntimeRoundTripTest.java
index 0a5123ce6..b77e111c0 100644
--- a/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EjectRuntimeRoundTripTest.java
+++ b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EjectRuntimeRoundTripTest.java
@@ -140,6 +140,11 @@ public void eachJavaGeneratorsOutputImportsExactlyTheRuntimeItsEntryDeclares() t
             Generator gen = (Generator) Class.forName(e.classname).getDeclaredConstructor().newInstance();
             Map<String, String> a = args(out);
             a.put("runtimePackage", probe);
+            // A single-file generator (the docs, diagram and schema ones) is told its file's name;
+            // a per-object one given one would merge every object into it.
+            if (!(gen instanceof com.metaobjects.generator.direct.MultiFileDirectGeneratorBase)) {
+                a.put("outputFilename", e.stableName + ".out");
+            }
             gen.setArgs(a).execute(loader);
 
             Set<String> all = imports(out);
diff --git a/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EjectSupportTest.java b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EjectSupportTest.java
index 280dbc26a..6e52b741f 100644
--- a/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EjectSupportTest.java
+++ b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EjectSupportTest.java
@@ -55,17 +55,34 @@ public void entityAndExtractorAreEjectableOnBothPortsAndSoNeedAPort() {
     }
 
     @Test
-    public void onlyTheJavaExtractorCarriesAWiringNoteAndItNamesTheOwnedClass() {
+    public void theJavaExtractorAndApiDocsOnBothPortsCarryAWiringNoteAndItNamesTheOwnedClass() {
+        int noted = 0;
         for (EjectSupport.Entry e : EjectSupport.allEntries()) {
             boolean javaExtractor = e.port == EjectSupport.Port.JAVA && e.stableName.equals("extractor");
-            if (!javaExtractor) {
-                assertNull(e.port.id + " " + e.stableName, e.wiringNote("com.acme.codegen"));
+            boolean apiDocs = e.stableName.equals("api-docs");
+            String note = e.wiringNote("com.acme.codegen");
+            if (!javaExtractor && !apiDocs) {
+                assertNull(e.port.id + " " + e.stableName, note);
                 continue;
             }
-            String note = e.wiringNote("com.acme.codegen");
-            assertTrue(note, note.contains(
-                    "<classname>com.acme.codegen.ExtractorCodeGenerator</classname>"));
+            noted++;
+            String ownedPackage = apiDocs ? "com.acme.codegen.apidocs." + e.port.id : "com.acme.codegen";
+            assertTrue(note, note.contains("<classname>" + ownedPackage + "." + e.simpleName() + "</classname>"));
             assertFalse(note, note.contains("{owned}"));
+            // The goal that runs it is the one that runs every generator, on either port.
+            if (apiDocs) assertTrue(note, note.contains("`mvn metaobjects:generate` runs this generator"));
+        }
+        assertEquals("the Java extractor, and api-docs on each port", 3, noted);
+    }
+
+    @Test
+    public void onlyTheApiDocsCopiesTakeASubpackageAndEachPortHasItsOwn() {
+        // The two ports' api reference classes share simple names, and one module may own both.
+        // Every other generator keeps the package it ejected into before 1.1.
+        for (EjectSupport.Entry e : EjectSupport.allEntries()) {
+            String expected = e.stableName.equals("api-docs")
+                    ? "com.acme.codegen.apidocs." + e.port.id : "com.acme.codegen";
+            assertEquals(e.port.id + " " + e.stableName, expected, e.ownedPackage("com.acme.codegen"));
         }
     }
 
@@ -163,8 +180,8 @@ public void rewritePackageRejectsSourceWithNoPackageLine() {
     /**
      * ADR-0034 Amendment 6: an owned generator extends and calls the classes copied with it,
      * never the packaged ones. So an import of a copied class follows the copy, and an
-     * import of anything else (here the {@code extractor} generator, which is not part of
-     * {@code entity}'s copy, and a class whose name merely starts like a copied one) stays.
+     * import of anything else (here the file writer, which is engine, and a class whose name
+     * merely starts like a copied one) stays.
      */
     @Test
     public void anImportOfAClassCopiedAlongFollowsTheCopyAndNoOtherImportMoves() {
@@ -173,14 +190,14 @@ public void anImportOfAClassCopiedAlongFollowsTheCopyAndNoOtherImportMoves() {
         String src = "package com.metaobjects.generator.direct.object.javacode;\n\n"
                 + "import com.metaobjects.generator.direct.object.BaseObjectCodeWriter;\n"
                 + "import com.metaobjects.generator.direct.object.BaseObjectCodeWriterFactory;\n"
-                + "import com.metaobjects.generator.direct.object.javacode.ExtractorCodeGenerator;\n"
+                + "import com.metaobjects.generator.util.GeneratedFileWriter;\n"
                 + "import com.metaobjects.generator.direct.GenerationContext;\n\n"
                 + "public class Foo extends BaseObjectCodeWriter {}\n";
 
         assertEquals("package com.metaobjects.generator.direct.object.javacode;\n\n"
                 + "import com.acme.codegen.BaseObjectCodeWriter;\n"
                 + "import com.metaobjects.generator.direct.object.BaseObjectCodeWriterFactory;\n"
-                + "import com.metaobjects.generator.direct.object.javacode.ExtractorCodeGenerator;\n"
+                + "import com.metaobjects.generator.util.GeneratedFileWriter;\n"
                 + "import com.metaobjects.generator.direct.GenerationContext;\n\n"
                 + "public class Foo extends BaseObjectCodeWriter {}\n",
                 EjectSupport.rewriteCopiedImports(src, entity.sources(), "com.acme.codegen"));
@@ -282,4 +299,66 @@ public void onlyTheJavaWebTierCarriesRuntime() {
             assertEquals(e.port.id + " " + e.stableName, expected, !e.runtime.isEmpty());
         }
     }
+
+    // ------------------------------------------------------------------------------------
+    // Kotlin imports, template prefix, and the ownership comparison across copies
+    // ------------------------------------------------------------------------------------
+
+    @Test
+    public void aKotlinImportOfAClassCopiedAlongFollowsTheCopyWithoutGainingASemicolon() {
+        String src = "package com.metaobjects.generator.kotlin\n\n"
+                + "import com.metaobjects.generator.kotlin.KotlinEnumEmitter\n"
+                + "import com.metaobjects.generator.kotlin.KotlinEnumEmitterFactory\n"
+                + "import com.metaobjects.generator.kotlin.KotlinNaming\n\n"
+                + "class Foo\n";
+        assertEquals("package com.metaobjects.generator.kotlin\n\n"
+                + "import com.acme.codegen.KotlinEnumEmitter\n"
+                + "import com.metaobjects.generator.kotlin.KotlinEnumEmitterFactory\n"
+                + "import com.metaobjects.generator.kotlin.KotlinNaming\n\n"
+                + "class Foo\n",
+                EjectSupport.rewriteCopiedImports(src,
+                        List.of("com.metaobjects.generator.kotlin.KotlinEnumEmitter"), "com.acme.codegen"));
+    }
+
+    @Test
+    public void everyKotlinEntryResolvesItsCopiedClassesToKotlinSources() {
+        EjectSupport.Entry entity = EjectSupport.resolve(
+                "entity", EjectSupport.ejectableByStableName(), EjectSupport.Port.KOTLIN, null).entry;
+        assertEquals(List.of("com.metaobjects.generator.kotlin.KotlinEntityGenerator",
+                "com.metaobjects.generator.kotlin.KotlinEnumEmitter"), entity.sources());
+        assertTrue(entity.resourceOf("com.metaobjects.generator.kotlin.KotlinEnumEmitter"),
+                entity.resourceOf("com.metaobjects.generator.kotlin.KotlinEnumEmitter")
+                        .endsWith("/kotlin/KotlinEnumEmitter.kt"));
+    }
+
+    @Test
+    public void aCopiedTemplateProviderIsPointedAtTheOwnedPackagesTemplates() {
+        String src = "package com.metaobjects.generator.apidocs;\n\npublic final class P {\n"
+                + "    private static final String BASE_PREFIX = \"templates/\";\n}\n";
+        assertEquals("com/acme/codegen/templates/", EjectSupport.ownedTemplatePrefix("com.acme.codegen"));
+        String owned = EjectSupport.rewriteTemplatePrefix(src, "com.acme.codegen");
+        assertTrue(owned, owned.contains("BASE_PREFIX = \"com/acme/codegen/templates/\";"));
+        // A source with no such declaration is returned as it came.
+        assertEquals("class X {}\n", EjectSupport.rewriteTemplatePrefix("class X {}\n", "com.acme.codegen"));
+        // The rewritten line is eject's own edit, so the copy still compares identical.
+        assertEquals(EjectSupport.Verdict.IDENTICAL, EjectSupport.compare(
+                EjectSupport.rewritePackage(owned, "com.acme.codegen"), src).verdict);
+    }
+
+    @Test
+    public void aFileTwoGeneratorsCopyComparesIdenticalWhicheverOneWroteIt() {
+        // The extractor is copied with entity, which points its import of the entity's base at the
+        // owned copy, and on its own, which leaves that import on the engine. Either way it is the
+        // reference: the import is eject's own edit.
+        String ref = "package com.metaobjects.generator.direct.object.javacode;\n\n"
+                + "import com.metaobjects.generator.direct.object.BaseObjectCodeGenerator;\n"
+                + "import com.metaobjects.generator.util.GeneratorUtil;\n\npublic class E {}\n";
+        String viaEntity = ref.replace("com.metaobjects.generator.direct.object.BaseObjectCodeGenerator",
+                "com.acme.codegen.BaseObjectCodeGenerator")
+                .replace("package com.metaobjects.generator.direct.object.javacode;", "package com.acme.codegen;");
+        assertEquals(EjectSupport.Verdict.IDENTICAL, EjectSupport.compare(viaEntity, ref).verdict);
+        // An import of anything else is still compared.
+        assertEquals(EjectSupport.Verdict.DIFFERS,
+                EjectSupport.compare(viaEntity.replace("GeneratorUtil", "OtherUtil"), ref).verdict);
+    }
 }
diff --git a/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EmitExtractorsDerivationTest.java b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EmitExtractorsDerivationTest.java
deleted file mode 100644
index da81488c8..000000000
--- a/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EmitExtractorsDerivationTest.java
+++ /dev/null
@@ -1,103 +0,0 @@
-package com.metaobjects.mojo;
-
-import com.metaobjects.generator.EmitsObjectExtractors;
-import org.junit.Before;
-import org.junit.Test;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-
-/**
- * The mojo tells the Java {@code entity} generator when a separate {@code extractor}
- * generator is in the run, so each {@code <Name>Extractor} has one emitter.
- *
- * <p>{@link UseNamesDerivationTest} holds the same seam for the names artifact, and for the
- * same reason: each generator's own tests construct it directly and never reach
- * {@link AbstractMetaDataMojo#buildGenerators}, so the derivation could be dropped there
- * with nothing failing. What would fail is an adopter's build, on the first edit to an owned
- * extractor, as an output path collision with the copy {@code entity} still wrote.</p>
- */
-public class EmitExtractorsDerivationTest {
-
-    /**
-     * Declares that it writes the extractors as a generator of its own. The arg recorder is
-     * the sibling names test's shared {@code RecordingGenerator} — same package, same seam,
-     * one recorder rather than a copy that can drift from the other.
-     */
-    public static class RecordingExtractorGenerator extends UseNamesDerivationTest.RecordingGenerator
-            implements EmitsObjectExtractors { }
-
-    private MetaDataGeneratorMojo mojo;
-
-    @Before
-    public void setUp() {
-        UseNamesDerivationTest.RecordingGenerator.SEEN.clear();
-        mojo = new MetaDataGeneratorMojo();
-        mojo.setLoader(new LoaderParam());
-    }
-
-    private static GeneratorParam param(Class<?> impl, Map<String, String> args) {
-        GeneratorParam p = new GeneratorParam();
-        p.setClassname(impl.getName());
-        if (args != null) p.setArgs(args);
-        return p;
-    }
-
-    private List<Map<String, String>> run(GeneratorParam... params) {
-        mojo.setGenerators(List.of(params));
-        mojo.buildGenerators(getClass().getClassLoader(), null);
-        return UseNamesDerivationTest.RecordingGenerator.SEEN;
-    }
-
-    @Test
-    public void a_separate_extractor_in_the_run_tells_every_generator_not_to_write_them() {
-        List<Map<String, String>> seen = run(
-                param(UseNamesDerivationTest.RecordingGenerator.class, null),
-                param(RecordingExtractorGenerator.class, null));
-
-        assertEquals(2, seen.size());
-        for (Map<String, String> args : seen) {
-            assertEquals("false", args.get(EmitsObjectExtractors.ARG_EMIT_EXTRACTORS));
-        }
-    }
-
-    @Test
-    public void a_run_without_one_leaves_the_arg_unset_so_entity_writes_them_as_before() {
-        List<Map<String, String>> seen = run(param(UseNamesDerivationTest.RecordingGenerator.class, null));
-
-        assertEquals(1, seen.size());
-        assertFalse(seen.get(0).containsKey(EmitsObjectExtractors.ARG_EMIT_EXTRACTORS));
-    }
-
-    /**
-     * One emitter per file is not a preference a pom can pin the other way. A {@code true}
-     * here used to win, which put {@code entity} back on the paths the separate extractor
-     * writes: the same bytes until the owned extractor is edited, then an output path
-     * collision.
-     */
-    @Test
-    public void an_explicit_true_in_the_pom_does_not_bring_back_a_second_emitter() {
-        Map<String, String> pinned = new HashMap<>();
-        pinned.put(EmitsObjectExtractors.ARG_EMIT_EXTRACTORS, "true");
-
-        List<Map<String, String>> seen = run(
-                param(UseNamesDerivationTest.RecordingGenerator.class, pinned),
-                param(RecordingExtractorGenerator.class, null));
-
-        assertEquals("false", seen.get(0).get(EmitsObjectExtractors.ARG_EMIT_EXTRACTORS));
-    }
-
-    @Test
-    public void an_explicit_false_with_no_separate_extractor_is_passed_through() {
-        Map<String, String> pinned = new HashMap<>();
-        pinned.put(EmitsObjectExtractors.ARG_EMIT_EXTRACTORS, "false");
-
-        List<Map<String, String>> seen = run(param(UseNamesDerivationTest.RecordingGenerator.class, pinned));
-
-        assertEquals("false", seen.get(0).get(EmitsObjectExtractors.ARG_EMIT_EXTRACTORS));
-    }
-}
diff --git a/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EntityExtractorEjectRoundTripTest.java b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EntityExtractorEjectRoundTripTest.java
index 69b2e0f53..d54408942 100644
--- a/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EntityExtractorEjectRoundTripTest.java
+++ b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EntityExtractorEjectRoundTripTest.java
@@ -1,6 +1,5 @@
 package com.metaobjects.mojo;
 
-import com.metaobjects.generator.EmitsObjectExtractors;
 import com.metaobjects.generator.Generator;
 import com.metaobjects.generator.direct.object.javacode.ExtractorCodeGenerator;
 import com.metaobjects.generator.direct.object.javacode.JavaObjectCodeGenerator;
@@ -38,6 +37,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.TreeMap;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -225,7 +225,7 @@ public void anUnchangedEjectedEntityWritesWhatThePackagedOneWritesInEveryFlavor(
     }
 
     @Test
-    public void anUnchangedEjectedExtractorWritesWhatThePackagedOneAndEntityWrite() throws Exception {
+    public void anUnchangedEjectedExtractorWritesWhatThePackagedOneWritesAndEntityWritesNone() throws Exception {
         ClassLoader classes = compileOwned(ejectBoth(tempFolder.newFolder("adopter").toPath()));
 
         Map<String, String> packaged = generate(new ExtractorCodeGenerator(), Map.of());
@@ -233,10 +233,13 @@ public void anUnchangedEjectedExtractorWritesWhatThePackagedOneAndEntityWrite()
         assertTrue("the corpus generated only " + packaged.size() + " extractors", packaged.size() >= 17);
         assertSameTree("extractor", packaged, copy);
 
-        // And they are the files entity writes when no separate extractor is in the run.
-        Map<String, String> fromEntity = new TreeMap<>(generate(new JavaObjectCodeGenerator(), POJO));
-        fromEntity.keySet().removeIf(path -> !path.endsWith("Extractor.java"));
-        assertSameTree("extractor, against entity's own", fromEntity, copy);
+        // Only the extractor generator writes them: entity, packaged or owned, writes none.
+        for (Generator entity : List.of(new JavaObjectCodeGenerator(), owned(classes, OWNED_ENTITY))) {
+            Map<String, String> fromEntity = new TreeMap<>(generate(entity, POJO));
+            fromEntity.keySet().removeIf(path -> !path.endsWith("Extractor.java"));
+            assertEquals(entity.getClass().getName() + " wrote extractors no entry declared",
+                    Set.of(), fromEntity.keySet());
+        }
     }
 
     // ------------------------------------------------------------------------------------
@@ -255,8 +258,7 @@ public void anEditToEachOwnedCopyShowsInItsOutput() throws Exception {
         Map<String, String> entity = generate(owned(classes, OWNED_ENTITY), POJO);
         assertTrue(entity.get("com/metaobjects/generated/GeneratedObjectClassBindingProvider.java")
                 .contains("GENERATED (owned entity copy)"));
-        // The owned entity still calls the PACKAGED extractor: it imports that class by name.
-        assertFalse(entity.get("fitness/ProgramExtractor.java").contains("owned extractor copy"));
+        assertFalse("entity writes no extractor", entity.containsKey("fitness/ProgramExtractor.java"));
 
         Map<String, String> extractor = generate(owned(classes, OWNED_EXTRACTOR), Map.of());
         assertTrue(extractor.get("fitness/ProgramExtractor.java").contains("GENERATED (owned extractor copy)"));
@@ -310,9 +312,7 @@ public void theOwnedExtractorNamesItsClassesThroughTheOwnedWriter() throws Excep
                 "return GeneratorUtil.toCamelCase(name, true) + \"Row\";\n    }\n\n    @Override\n    protected void writeGetter");
         ClassLoader classes = compileOwned(ownedDir);
 
-        Map<String, String> entity = new HashMap<>(POJO);
-        entity.put(EmitsObjectExtractors.ARG_EMIT_EXTRACTORS, "false");
-        String program = generate(owned(classes, OWNED_ENTITY), entity).get("fitness/Program.java");
+        String program = generate(owned(classes, OWNED_ENTITY), POJO).get("fitness/Program.java");
         assertTrue(program, program.contains("public class ProgramRow extends "));
 
         Map<String, String> extractors = generate(owned(classes, OWNED_EXTRACTOR), Map.of());
@@ -373,10 +373,11 @@ public void theListingReportsBothAsEjectableAndMarksTheirOwnedCopies() throws Ex
         String edited = list(projectDir);
         assertTrue(row(edited, "extractor"),
                 row(edited, "extractor").endsWith("[owned — DIFFERS: 1 behind, 1 of your own]"));
+        // entity copies no extractor, so its row does not move.
         assertTrue(row(edited, "entity"), row(edited, "entity").endsWith("[owned — identical]"));
 
         // A writer is part of the generator it was copied with: an edit to one only entity
-        // has shows on entity's row, and leaves the extractor's count where it was.
+        // has shows on entity's row and leaves the extractor's count where it was.
         edit(ownedDir.resolve("PojoAwareCodeWriter.java"),
                 "println(true, \"super(mo);\");", "println(true, \"super(mo); // mine\");");
         String writerEdited = list(projectDir);
@@ -397,7 +398,7 @@ public void ejectingTheExtractorSaysHowToWireAGeneratorThePomMayNotNameYet() thr
 
         String out = logged(log);
         assertTrue(out, out.contains("<generator><classname>" + OWNED_EXTRACTOR + "</classname></generator>"));
-        assertTrue(out, out.contains("`entity` then leaves those files to it"));
+        assertTrue(out, out.contains("only this generator writes the <Name>Extractor classes"));
     }
 
     @Test
@@ -463,7 +464,7 @@ public void theDriftCheckRunsTheOwnedCopiesAndReportsWhatTheyNoLongerProduce() t
 
         Path committed = generatedInSync(classes);
 
-        // One emitter per file: with the extractor in <generators>, entity left them to it.
+        // The extractors come from the extractor entry, the provider from the entity entry.
         assertTrue(Files.readString(committed.resolve("fitness/ProgramExtractor.java"))
                 .contains("GENERATED (owned extractor copy)"));
         assertTrue(Files.readString(committed.resolve(
diff --git a/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/KotlinGeneratorInfoJavaCallerTest.java b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/KotlinGeneratorInfoJavaCallerTest.java
new file mode 100644
index 000000000..9026dfa9e
--- /dev/null
+++ b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/KotlinGeneratorInfoJavaCallerTest.java
@@ -0,0 +1,25 @@
+package com.metaobjects.mojo;
+
+import com.metaobjects.generator.kotlin.GeneratorInfo;
+import com.metaobjects.generator.kotlin.GeneratorLayer;
+import com.metaobjects.generator.kotlin.GeneratorTier;
+import com.metaobjects.generator.kotlin.KotlinNamesGenerator;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+/** A Java caller of the six-argument {@code GeneratorInfo} constructor, as 1.0 shipped it, still links. */
+public class KotlinGeneratorInfoJavaCallerTest {
+
+    @Test
+    public void theSixArgumentConstructorStillExistsAndLeavesNothingToCopyWithIt() {
+        GeneratorInfo info = new GeneratorInfo("names", "d", GeneratorTier.NATIVE, GeneratorLayer.MODEL,
+                KotlinNamesGenerator::new, "META-INF/metaobjects/reference/kotlin/KotlinNamesGenerator.kt");
+        assertEquals("names", info.getName());
+        assertEquals(java.util.List.of(), info.getEjectWith());
+        // And the five-argument form it was a default-argument overload of.
+        assertNull(new GeneratorInfo("names", "d", GeneratorTier.NATIVE, GeneratorLayer.MODEL,
+                KotlinNamesGenerator::new).getEjectResourcePath());
+    }
+}
diff --git a/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/MetaDataEjectMojoTest.java b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/MetaDataEjectMojoTest.java
index 79bd685ff..8baf5a704 100644
--- a/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/MetaDataEjectMojoTest.java
+++ b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/MetaDataEjectMojoTest.java
@@ -330,4 +330,29 @@ public void namesIsRequiredWhenNotListing() {
             fail("expected MojoFailureException, got " + e);
         }
     }
+
+    // ------------------------------------------------------------------------------------
+    // api-docs: the templates its page text reads come with it
+    // ------------------------------------------------------------------------------------
+
+    @Test
+    public void ejectingTheJavaApiDocsWritesTheTemplatesAndPointsTheCopiedProviderAtThem() throws Exception {
+        mojo("api-docs", false, "java", null).execute();
+
+        // The api-docs copies take the Java subpackage of the owned package.
+        Path src = codegenRoot().resolve("src/main/java/com/acme/codegen/apidocs/java");
+        for (String file : List.of("JavaApiDocsGenerator", "JavaApiModelBuilder", "JavaApiDocsRenderer",
+                "DocsPaths", "ApiUnit", "ClasspathTemplateProvider")) {
+            assertTrue(file, Files.isRegularFile(src.resolve(file + ".java")));
+        }
+        // The page text is the adopter's, under the copies' package path so no jar can shadow it.
+        Path templates = codegenRoot().resolve("src/main/resources/com/acme/codegen/apidocs/java/templates/api");
+        for (String name : List.of("entity-api", "index", "agent-api")) {
+            assertTrue(name, Files.isRegularFile(templates.resolve(name + ".md.mustache")));
+        }
+        String provider = Files.readString(src.resolve("ClasspathTemplateProvider.java"), StandardCharsets.UTF_8);
+        assertTrue(provider, provider.contains("BASE_PREFIX = \"com/acme/codegen/apidocs/java/templates/\";"));
+        String generator = Files.readString(src.resolve("JavaApiDocsGenerator.java"), StandardCharsets.UTF_8);
+        assertTrue(generator, generator.contains("package com.acme.codegen.apidocs.java;"));
+    }
 }
diff --git a/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/RemovedDocsGoalTest.java b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/RemovedDocsGoalTest.java
new file mode 100644
index 000000000..63fecfad0
--- /dev/null
+++ b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/RemovedDocsGoalTest.java
@@ -0,0 +1,116 @@
+package com.metaobjects.mojo;
+
+import org.apache.maven.plugin.Mojo;
+import org.apache.maven.plugin.MojoFailureException;
+import org.apache.maven.plugin.testing.MojoRule;
+import org.codehaus.plexus.PlexusTestCase;
+import org.junit.Rule;
+import org.junit.Test;
+import org.w3c.dom.Element;
+import org.w3c.dom.NodeList;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+import java.io.File;
+import java.io.InputStream;
+import java.nio.file.Files;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+
+/**
+ * An 8.0 pom is never run quietly into a build with no documentation (ADR-0034 Amendment 9).
+ * The removed {@code docs} goal says what replaced it, and the goals that remain refuse the
+ * {@code docs} goal's configuration by name, each with the sentence the amendment fixes.
+ */
+public class RemovedDocsGoalTest {
+
+    private static final String MIGRATION =
+            "See docs/features/migrations/docs-are-generators.md, section \"Java and Kotlin\".";
+
+    @Rule
+    public MojoRule rule = new MojoRule();
+
+    private static File pom() {
+        return new File(PlexusTestCase.getBasedir(), "src/test/resources/mojo/pom-docs-8-0.xml");
+    }
+
+    private static String refusalOf(Mojo mojo) throws Exception {
+        try {
+            mojo.execute();
+        } catch (MojoFailureException e) {
+            return e.getMessage();
+        }
+        fail(mojo.getClass().getSimpleName() + " ran an 8.0 pom");
+        return null;
+    }
+
+    @Test
+    public void theDocsGoalSaysItWasRemovedAndWhatWritesDocumentationNow() throws Exception {
+        assertEquals(
+                "metaobjects:docs was removed in 8.1.0. `mvn metaobjects:generate` writes documentation "
+                    + "now: declare each docs generator as a <generator> entry in the plugin's "
+                    + "<generators>. " + MIGRATION,
+                // Built directly: Maven hands a goal only the <configuration> elements it declares,
+                // and this one declares none. The test harness's configurator refuses the rest.
+                refusalOf(new DocsMojo()));
+    }
+
+    @Test
+    public void anExecutionThatBindsTheDocsGoalWithNoPhaseIsStillScheduled() throws Exception {
+        // The 8.0 pom binds <goal>docs</goal> with no <phase>. Maven schedules such an execution
+        // through the phase in the plugin descriptor, and skips it when there is none, so the
+        // refusal above would never run. The descriptor is what Maven reads; the 8.0 goal said
+        // generate-resources.
+        assertEquals("generate-resources", descriptorPhaseOf("docs"));
+    }
+
+    private static String descriptorPhaseOf(String goal) throws Exception {
+        try (InputStream in = RemovedDocsGoalTest.class.getClassLoader()
+                .getResourceAsStream("META-INF/maven/plugin.xml")) {
+            assertNotNull("plugin.xml descriptor must be generated before tests run", in);
+            NodeList mojos = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(in)
+                    .getDocumentElement().getElementsByTagName("mojo");
+            for (int i = 0; i < mojos.getLength(); i++) {
+                Element mojo = (Element) mojos.item(i);
+                if (goal.equals(childText(mojo, "goal"))) {
+                    return childText(mojo, "phase");
+                }
+            }
+            fail("no <mojo> for goal '" + goal + "' in the plugin descriptor");
+            return null;
+        }
+    }
+
+    private static String childText(Element parent, String name) {
+        for (org.w3c.dom.Node n = parent.getFirstChild(); n != null; n = n.getNextSibling()) {
+            if (n instanceof Element && name.equals(n.getNodeName())) {
+                return n.getTextContent().trim();
+            }
+        }
+        return null;
+    }
+
+    @Test
+    public void theGenerateGoalRefusesTheDocsGoalsConfigurationAndWritesNothing() throws Exception {
+        assertEquals(
+                "metaobjects:generate: found 1.0 docs configuration (<language>, <layout> in the plugin's "
+                    + "<configuration>). Nothing reads it any more, so this run would write no "
+                    + "documentation. Declare each docs generator as a <generator> entry in the plugin's "
+                    + "<generators>. " + MIGRATION,
+                refusalOf(rule.lookupMojo("generate", pom())));
+        // Refused before the list ran: the pom's one code generator wrote nothing either.
+        assertFalse(Files.exists(new File(PlexusTestCase.getBasedir(), "target/docs-8-0-test").toPath()));
+    }
+
+    @Test
+    public void theVerifyGoalRefusesItToo() throws Exception {
+        assertEquals(
+                "metaobjects:verify: found 1.0 docs configuration (<language>, <layout> in the plugin's "
+                    + "<configuration>). Nothing reads it any more, so this run would write no "
+                    + "documentation. Declare each docs generator as a <generator> entry in the plugin's "
+                    + "<generators>. " + MIGRATION,
+                refusalOf(rule.lookupMojo("verify", pom())));
+    }
+}
diff --git a/server/java/maven-plugin/src/test/resources/mojo/pom-docs-kotlin.xml b/server/java/maven-plugin/src/test/resources/mojo/pom-api-docs.xml
similarity index 52%
rename from server/java/maven-plugin/src/test/resources/mojo/pom-docs-kotlin.xml
rename to server/java/maven-plugin/src/test/resources/mojo/pom-api-docs.xml
index 37f2381a1..c192c87f9 100644
--- a/server/java/maven-plugin/src/test/resources/mojo/pom-docs-kotlin.xml
+++ b/server/java/maven-plugin/src/test/resources/mojo/pom-api-docs.xml
@@ -12,7 +12,7 @@
     </dependencies>
 
     <build>
-        <directory>target/docs-mojo-test-kotlin</directory>
+        <directory>target/api-docs-test</directory>
         <plugins>
             <plugin>
                 <groupId>com.metaobjects</groupId>
@@ -24,20 +24,38 @@
                     <lax>true</lax>
                     <loader>
                         <classname>com.metaobjects.loader.MetaDataLoader</classname>
-                        <name>docs-mojo-test-kotlin-pom</name>
+                        <name>api-docs-test-pom</name>
                         <sourceDir>./src/test/resources</sourceDir>
                         <sources>
                             <source>mojo/mojo-test-metadata.json</source>
                         </sources>
                     </loader>
-                    <outputDirectory>target/docs-mojo-test-kotlin/docs</outputDirectory>
-                    <language>kotlin</language>
-                    <layout>package</layout>
+                    <!-- The api reference is a <generator> entry like any other (ADR-0034
+                         Amendment 9): one per language, each with its options in <args>. The Java
+                         entry sets every option; the Kotlin entry takes every default. -->
+                    <generators>
+                        <generator>
+                            <classname>com.metaobjects.generator.apidocs.JavaApiDocsGenerator</classname>
+                            <args>
+                                <outputDir>target/api-docs-test/docs</outputDir>
+                                <apiSubDir>reference/java</apiSubDir>
+                                <layout>package</layout>
+                                <projectName>fruit-shop</projectName>
+                                <modelBaseUrl>https://docs.example.test/model</modelBaseUrl>
+                            </args>
+                        </generator>
+                        <generator>
+                            <classname>com.metaobjects.generator.kotlin.apidocs.KotlinApiDocsGenerator</classname>
+                            <args>
+                                <outputDir>target/api-docs-test/docs</outputDir>
+                            </args>
+                        </generator>
+                    </generators>
                 </configuration>
                 <executions>
                     <execution>
                         <goals>
-                            <goal>docs</goal>
+                            <goal>generate</goal>
                         </goals>
                     </execution>
                 </executions>
diff --git a/server/java/maven-plugin/src/test/resources/mojo/pom-docs.xml b/server/java/maven-plugin/src/test/resources/mojo/pom-docs-8-0.xml
similarity index 65%
rename from server/java/maven-plugin/src/test/resources/mojo/pom-docs.xml
rename to server/java/maven-plugin/src/test/resources/mojo/pom-docs-8-0.xml
index f172d1ce4..192e0ead6 100644
--- a/server/java/maven-plugin/src/test/resources/mojo/pom-docs.xml
+++ b/server/java/maven-plugin/src/test/resources/mojo/pom-docs-8-0.xml
@@ -12,11 +12,13 @@
     </dependencies>
 
     <build>
-        <directory>target/docs-mojo-test</directory>
+        <directory>target/docs-8-0-test</directory>
         <plugins>
             <plugin>
                 <groupId>com.metaobjects</groupId>
                 <artifactId>metaobjects-maven-plugin</artifactId>
+                <!-- An 8.0 pom, kept as it was written: the docs goal bound, and its parameters
+                     in the plugin-level <configuration> beside the generate goal's list. -->
                 <configuration>
                     <!-- #96: the shared fixture carries a custom @simple::fruitbasket::isKey
                          attribute (declared by no registered provider); this docs test is
@@ -24,19 +26,28 @@
                     <lax>true</lax>
                     <loader>
                         <classname>com.metaobjects.loader.MetaDataLoader</classname>
-                        <name>docs-mojo-test-pom</name>
+                        <name>docs-8-0-test-pom</name>
                         <sourceDir>./src/test/resources</sourceDir>
                         <sources>
                             <source>mojo/mojo-test-metadata.json</source>
                         </sources>
                     </loader>
-                    <outputDirectory>target/docs-mojo-test/docs</outputDirectory>
-                    <apiSubDir>api/java</apiSubDir>
+                    <outputDirectory>target/docs-8-0-test/docs</outputDirectory>
+                    <language>java,kotlin</language>
                     <layout>package</layout>
+                    <generators>
+                        <generator>
+                            <classname>com.metaobjects.generator.spring.SpringDtoGenerator</classname>
+                            <args>
+                                <outputDir>target/docs-8-0-test/generated</outputDir>
+                            </args>
+                        </generator>
+                    </generators>
                 </configuration>
                 <executions>
                     <execution>
                         <goals>
+                            <goal>generate</goal>
                             <goal>docs</goal>
                         </goals>
                     </execution>
diff --git a/server/typescript/packages/cli/src/lib/docs-drift.ts b/server/typescript/packages/cli/src/lib/docs-drift.ts
index 9f9343840..e19dc687b 100644
--- a/server/typescript/packages/cli/src/lib/docs-drift.ts
+++ b/server/typescript/packages/cli/src/lib/docs-drift.ts
@@ -25,7 +25,7 @@
 //      default moved to `./docs/generated` for exactly that reason: defaulting into the
 //      most-owned directory name in the ecosystem contradicted this paragraph.) Its
 //      `api/` subtree is not ours either: on a multi-port project those pages are written
-//      by the OTHER port's docs command (`mvn metaobjects:docs`, `metaobjects docs`,
+//      by the OTHER port's docs writer (`mvn metaobjects:generate`, `metaobjects docs`,
 //      `dotnet meta docs`), which this gate never runs, so a fresh run here legitimately
 //      emits none of them. `--codegen` can convict a committed-but-not-regenerated file
 //      because `.gen-state` proves the generator wrote it; over the docs root there is no
diff --git a/server/typescript/packages/sdk/src/agent-context/assemble.ts b/server/typescript/packages/sdk/src/agent-context/assemble.ts
index 7ea8ae4fb..31fcf2f7f 100644
--- a/server/typescript/packages/sdk/src/agent-context/assemble.ts
+++ b/server/typescript/packages/sdk/src/agent-context/assemble.ts
@@ -27,11 +27,22 @@ interface ServerMeta {
   displayName: string;
   install: string;
   codegenCommand: string;
-  /** The command that writes THIS port's api docs — `mvn metaobjects:docs`, `metaobjects
+  /** The command that writes THIS port's api docs — `mvn metaobjects:generate`, `metaobjects
    *  docs`, `dotnet meta docs`, `meta docs`. Named per server because the always-on
    *  pointer tells a reader to run it, and a pointer naming a command the stack does not
    *  have is worse than no pointer. */
   docsCommand: string;
+  /** Appended after each mention of `docsCommand`: the condition under which it writes the
+   *  api pages, with its leading space, or `""` when it always does. The Maven `generate`
+   *  goal writes them only when the pom's generator list declares the api-docs generator,
+   *  and a pointer that omits that sends a reader to run a command that writes nothing. */
+  docsCondition: string;
+  /** What to do before running `docsCommand` when the api pages are missing, with no
+   *  trailing punctuation, or `""` when running it is the whole remedy. A Maven pom writes
+   *  them only once it declares the api-docs generator, and a missing entry is the usual
+   *  reason the file is absent, so the Not-there line names that entry instead of only the
+   *  command. */
+  docsMissing: string;
   /** The docs-root-relative directory THIS port's docs command writes its api pages into.
    *  It is NOT `api` outside TypeScript — Python defaults to `api/python`, C# to
    *  `api/csharp`, the Maven plugin to `api/<lang>` — so a pointer naming `api/AGENT-API.md`
@@ -49,7 +60,14 @@ function readServerMeta(contentRoot: string, server: string): ServerMeta | undef
 function stackLine(
   contentRoot: string,
   stack: Stack,
-): { line: string; codegenCommand: string; docsCommand: string; apiSubDir: string } {
+): {
+  line: string;
+  codegenCommand: string;
+  docsCommand: string;
+  docsCondition: string;
+  docsMissing: string;
+  apiSubDir: string;
+} {
   const primary = stack.servers[0];
   const meta = primary ? readServerMeta(contentRoot, primary) : undefined;
   const serverPart = stack.servers.length ? stack.servers.join(", ") + " server" : "no server";
@@ -63,6 +81,8 @@ function stackLine(
     line: `Stack: ${serverPart}, ${clientPart}.`,
     codegenCommand: meta ? meta.codegenCommand : "meta gen",
     docsCommand: meta ? meta.docsCommand : "meta docs",
+    docsCondition: meta ? meta.docsCondition : "",
+    docsMissing: meta ? meta.docsMissing : "",
     apiSubDir: meta ? meta.apiSubDir : "api",
   };
 }
@@ -137,10 +157,14 @@ export function assemble(opts: { contentRoot: string; stack: Stack }): Assembled
 
   // 1. Always-on (AGENTS.md + CLAUDE.md, identical contents).
   const tpl = readFileSync(join(contentRoot, "templates", "always-on.md.mustache"), "utf8");
-  const { line, codegenCommand, docsCommand, apiSubDir } = stackLine(contentRoot, stack);
+  const { line, codegenCommand, docsCommand, docsCondition, docsMissing, apiSubDir } = stackLine(
+    contentRoot,
+    stack,
+  );
+  const docsMissingAction = docsMissing === "" ? "Run" : `${docsMissing}, then run`;
   const alwaysOn = applyTemplate(
     tpl,
-    { stackLine: line, codegenCommand, docsCommand, apiSubDir },
+    { stackLine: line, codegenCommand, docsCommand, docsCondition, docsMissingAction, apiSubDir },
     { nodeDocsSurface: hasNodeDocsSurface(stack) },
   );
   out.push({ path: ".metaobjects/AGENTS.md", contents: alwaysOn });
diff --git a/server/typescript/packages/sdk/test/agent-context/assemble.test.ts b/server/typescript/packages/sdk/test/agent-context/assemble.test.ts
index c0ef32e0c..035b10a17 100644
--- a/server/typescript/packages/sdk/test/agent-context/assemble.test.ts
+++ b/server/typescript/packages/sdk/test/agent-context/assemble.test.ts
@@ -48,13 +48,36 @@ describe("assemble", () => {
     expect(python).toContain("written by the Node `meta docs` command and need a");
     expect(python).not.toContain("Not there? Run `meta docs`.");
 
+    // The Maven `generate` goal writes the api page only when the pom's generator list
+    // declares the api-docs generator, so a Java-only pointer says so beside the command.
+    const java = assemble({ contentRoot: CONTENT_ROOT, stack: makeStack(["java"], []) })
+      .find((f) => f.path === ".metaobjects/AGENTS.md")!.contents;
+    expect(java).toContain(
+      "`mvn metaobjects:generate` writes ONE reference file under this project's docs output " +
+        "directory (when the project's generator list declares the api-docs generator).",
+    );
+    // A missing api-docs entry is the usual reason the page is absent, so the Not-there line
+    // names the entry to declare before the command, rather than repeating the condition.
+    expect(java).toContain(
+      "Not there? Declare `com.metaobjects.generator.apidocs.JavaApiDocsGenerator` as a " +
+        "`<generator>` entry in the pom's `<generators>` if it is missing, then run " +
+        "`mvn metaobjects:generate`.",
+    );
+    const kotlin = assemble({ contentRoot: CONTENT_ROOT, stack: makeStack(["kotlin"], []) })
+      .find((f) => f.path === ".metaobjects/AGENTS.md")!.contents;
+    expect(kotlin).toContain(
+      "Not there? Declare `com.metaobjects.generator.kotlin.apidocs.KotlinApiDocsGenerator` as a " +
+        "`<generator>` entry in the pom's `<generators>` if it is missing, then run " +
+        "`mvn metaobjects:generate`.",
+    );
+
     // A Java backend serving React DOES run `meta gen`, so it gets the full pointer.
     const javaReact = assemble({ contentRoot: CONTENT_ROOT, stack: makeStack(["java"], ["react"]) })
       .find((f) => f.path === ".metaobjects/AGENTS.md")!.contents;
     expect(javaReact).toContain("`meta docs` writes four reference files");
 
     // No section tag survives substitution on any of them.
-    for (const c of [node, python, javaReact]) {
+    for (const c of [node, python, java, kotlin, javaReact]) {
       expect(c).not.toContain("{{#");
       expect(c).not.toContain("{{^");
       expect(c).not.toContain("{{/");
diff --git a/spec/decisions/ADR-0021-codegen-surface-coherence.md b/spec/decisions/ADR-0021-codegen-surface-coherence.md
index ce1ee8f12..a2a75f87a 100644
--- a/spec/decisions/ADR-0021-codegen-surface-coherence.md
+++ b/spec/decisions/ADR-0021-codegen-surface-coherence.md
@@ -5,6 +5,7 @@
 > historical record; ADR-0022 is the current canonical statement.
 
 **Status:** Superseded by ADR-0022
+**D1 superseded by ADR-0034 Amendment 9 (2026-10-12):** documentation is an ordinary entry in the project's generator list, run by the gen command; there is no docs door.
 **Extended by ADR-0025:** D1 (the single docs door) now covers ALL documentation, via two cross-linked surfaces (`model` / `api`) — see [ADR-0025](ADR-0025-unified-docs-door.md).
 **Date:** 2026-06-02
 **Relates to:** ADR-0020 (codegen tiering), ADR-0015/0016 (migrate engine)
diff --git a/spec/decisions/ADR-0022-codegen-and-docs-surface-architecture.md b/spec/decisions/ADR-0022-codegen-and-docs-surface-architecture.md
index 7c9cfed9e..ae9e76f32 100644
--- a/spec/decisions/ADR-0022-codegen-and-docs-surface-architecture.md
+++ b/spec/decisions/ADR-0022-codegen-and-docs-surface-architecture.md
@@ -4,6 +4,7 @@
 **Date:** 2026-06-04
 **Supersedes:** ADR-0020 (codegen tiering), ADR-0021 (codegen surface coherence)
 **Revised by ADR-0025 (docs surface):** Part 3's `api-docs` is the *api surface* of the unified docs door (`meta docs`), not a standalone `meta gen` generator — see [ADR-0025](ADR-0025-unified-docs-door.md).
+**Part 2 D1 superseded by ADR-0034 Amendment 9 (2026-10-12):** every generator, documentation included, is an entry in the project's generator list and runs through the gen command; the docs commands are removed. Part 3's dividing test stands as a description of two generators.
 **Relates to:** ADR-0015 (single shared migrate engine)
 
 > This ADR consolidates ADR-0020 + ADR-0021 and adds the documentation-surface
diff --git a/spec/decisions/ADR-0025-unified-docs-door.md b/spec/decisions/ADR-0025-unified-docs-door.md
index 4148fc8a7..a6851dc3d 100644
--- a/spec/decisions/ADR-0025-unified-docs-door.md
+++ b/spec/decisions/ADR-0025-unified-docs-door.md
@@ -1,6 +1,6 @@
 # ADR-0025: Unified docs door — one command, two surfaces, one config
 
-**Status:** Accepted
+**Status:** Accepted; superseded in part by ADR-0034 Amendment 9 (2026-10-12). D1, D2's defaults, D4 and the per-port commands of D5 no longer hold: there is no docs command in any port, and each surface is a generator the project declares in its generator list. The output tree and the cross-link contract of D2, D3 and D5 stand.
 **Date:** 2026-06-06
 **Extended by:** ADR-0027 (polyglot docs composition — the single api surface generalizes to a per-language `apiSurfaces[]` list)
 **Extends:** ADR-0021 D1 (single docs door — now covers ALL docs, not just neutral)
diff --git a/spec/decisions/ADR-0034-codegen-scaffold-and-own.md b/spec/decisions/ADR-0034-codegen-scaffold-and-own.md
index d0f4f1008..d919719e7 100644
--- a/spec/decisions/ADR-0034-codegen-scaffold-and-own.md
+++ b/spec/decisions/ADR-0034-codegen-scaffold-and-own.md
@@ -533,6 +533,10 @@ between the two generators.
 
 ### Amendment 7 (2026-10-11) — `shared-model`, `docs` and `api-docs` are ejectable; `mermaid-er` is removed; `template` is the one that is not
 
+> **Superseded in part by Amendment 9.** The docs door's seam below (`docs.generators`, the
+> `docsSurface` marker, the skip in `meta gen`) is gone: an owned docs copy is an entry in
+> `generators` like any other. The rulings on `shared-model`, `mermaid-er` and `template` stand.
+
 **Ruling (maintainer).** Amendment 5 recorded the rule, *"everything should be ejectable"*,
 and listed what still was not. An audit of every stock generator in all five ports then
 found eight that could not be ejected and recommended making all of them ejectable in 1.1.0
@@ -729,8 +733,8 @@ checked further by the guard.
 |---|---|
 | TypeScript | `requirement-walk.ts`, `relation-resolver.ts`, `render-context.ts`, `templates/find-inbound.ts`, `templates/find-templates.ts`, `render-engine/framework-provider.ts` |
 | C# | `ReportRows`, `PackageBindingResolver`, `GeneratorApplicability` |
-| Java | `BaseObjectCodeGenerator`, `SpringM2mSupport`, `AutoSetSupport`, `TphPlan`, `FindInbound` |
-| Kotlin | `ExposedApi`, `ExposedImports`, `KotlinGenUtil`, `KotlinM2mSupport` |
+| Java | `BaseObjectCodeGenerator`, `SpringM2mSupport`, `AutoSetSupport`, `TphPlan`, `FindInbound`, `GeneratorApplicability`, `CodeGenMetaDataProvider`, the single-file generator bases and the JSON and HTML writer bases (`SingleFileDirectGeneratorBase`, `SingleJsonDirectGeneratorBase`, `SingleHtmlDirectGeneratorBase`, `JsonDirectWriter`, `HtmlDirectWriter`) |
+| Kotlin | `ExposedApi`, `ExposedImports`, `KotlinGenUtil`, `KotlinM2mSupport`, `Fr019SharedEnum` |
 | Python | `value_objects`, `find_inbound`, `tph_plan`, `requirement_walk` |
 
 **Exemptions.** Each is an entry in the shared manifest with its reason.
@@ -828,16 +832,16 @@ refusal is then `scripts/finish-release.mjs`, which withholds the tag.
 | 1 | Java `routes`, `dto` and `value-object` did not compile when ejected alone. | Closed before this amendment |
 | 2 | TypeScript `requirementsFile` and `agentDocsFile` were in no registry. | Registered here as `requirements` and `agent-docs`; reference templates pending |
 | 3 | TypeScript reference templates that call packaged composers. | Pending |
-| 4 | Prompt-tier emitters that stay packaged in C#, Python, Java and Kotlin. | Closed in C# and Python. Pending in Java and Kotlin |
-| 5 | Fragment emitters behind otherwise whole generators (shared enums, M:N navigation, doc comments, record builders). | Closed in C# and Python. Pending in Java and Kotlin |
-| 6 | The docs command's emitter in C#, Python, Java and Kotlin is not a registered `api-docs`. | Closed in C# and Python. Pending in Java and Kotlin |
-| 7 | Java generators outside the registry. | Registered here as `plantuml`, `html-docs`, `ai-docs`, `json-schema` and `mustache`; eject source pending for the first four |
+| 4 | Prompt-tier emitters that stay packaged in C#, Python, Java and Kotlin. | Closed in C#, Python, Java and Kotlin |
+| 5 | Fragment emitters behind otherwise whole generators (shared enums, M:N navigation, doc comments, record builders). | Closed in C#, Python, Java and Kotlin. Kotlin `Fr019SharedEnum` is engine, not handed over: it writes nothing, and the type mapper takes its `ProvidedEnumConfig` as an argument |
+| 6 | The docs command's emitter in C#, Python, Java and Kotlin is not a registered `api-docs`. | Closed in C#, Python, Java and Kotlin |
+| 7 | Java generators outside the registry. | Registered here as `plantuml`, `html-docs`, `ai-docs`, `json-schema` and `mustache`. The first four ship eject source, each with its writer; `mustache` is exempt |
 | 8 | The docs-site builders. | Exempt (ruling 3) |
 | 9 | Python generators that called another generator's packaged module. | Closed before this amendment |
 | 10 | Angular has no reference templates. | Outside the census until the package is published |
 | 11 | Tests that asserted a gap, and hand-kept lists. | Closed here |
 | 12 | Documents that claimed more than the code delivered. | Corrected here, below |
-| 13 | An owned Java `entity` constructs the packaged `extractor` generator when no extractor is in the run. Found by the guard on its first run. | Pending. It closes with the Java work on gaps 4, 5 and 7, which owns the `entity` and `extractor` copies |
+| 13 | An owned Java `entity` constructs the packaged `extractor` generator when no extractor is in the run. Found by the guard on its first run. | Closed. `entity` writes no extractors and constructs no extractor generator; `extractor` is the one entry that writes them (Amendment 9) |
 
 **What the guard found on its first run**, beyond the gaps the audit listed:
 
@@ -871,9 +875,15 @@ is.
 
 - **Kotlin depth does not run the eject goal.** The goal lives in `maven-plugin`, which
   depends on `codegen-kotlin`, and the Kotlin compile test has to live in `codegen-kotlin`.
-  The test reads the reference source the jar ships and rewrites its package line, which
-  is the one edit eject makes to a Kotlin copy. If eject starts doing more than that, this
-  test will not see it.
+  The test reads the reference sources the jar ships (the generator and the classes eject
+  copies with it), rewrites each package line and the imports the copies have of one
+  another, and compiles them together. Those are the two edits eject makes to a Kotlin copy.
+  If eject starts doing more than that, this test will not see it.
+- **The Java docs generators' page templates are not in the reference scan.** `api-docs`
+  reads its page text from the classpath. Eject copies the templates into the adopter's
+  resources and points the copied provider at them, and the depth test puts those resources
+  on the owned classes' path so the copy reads them, but the scan sees classes, not text. A
+  template that called a packaged helper would not be seen.
 - **C# compiles the generator and the emitters eject hands over with it**, which is every
   file eject writes under `codegen/generators`. The helper-runtime files eject writes
   elsewhere are compiled by `HelperRuntimeTests`, against the web framework they need.
@@ -942,3 +952,224 @@ is.
   calling the package where it did; re-ejecting takes the whole emit.
 - **Packaged output.** This amendment adds registry rows and tests. No generator emits
   different bytes because of it.
+
+### Amendment 9 (2026-10-12) — one way to generate: every generator, docs included, is an entry in the project's generator list; the docs commands are removed
+
+**Ruling (maintainer).** Amendment 7 gave the docs door a list of its own, a marker on the
+generators it runs, and a skip in the gen command for anything carrying the marker. The ports
+that followed copied that shape. The maintainer then ruled it out:
+
+> *"Meta gen should never auto generate anything. There should be a config file (native
+> options can differ such as using maven) that says what is or isn't generated and what
+> inputs to pass in."*
+>
+> *"The java version using maven is not automatic. You only add it there if you want codgen.
+> Thats how it should fucking work. So java should do all codegen one way. All languages
+> should do it one way."*
+>
+> *"Get rid of it, as I don't see a benefit of having two approaches."* ("It" is the
+> separate docs command and the Maven docs goal.)
+>
+> *"Do A and call it 1.1.0."* (A is the whole redesign in one release.)
+>
+> *"You can also just have the LLM fix the fucking config files. We don't have to write
+> super complicated upgrade scripts all the time."*
+
+A survey of nine code generators (Prisma, GraphQL Code Generator, OpenAPI Generator, buf,
+jOOQ, sqlc, Smithy, TypeSpec, NSwag) found the same shape in each: one file lists the
+generators, each entry carries its own output location and options, documentation is one
+more entry in that list, and one command runs the list. None has a separate docs command.
+
+**The rule, for all five ports.**
+
+1. Every generator is an entry in the project's native generator list, with its inputs in
+   the entry. That includes the api reference, the model pages and every other page of
+   documentation.
+2. One command runs the list: `meta gen` (TypeScript), `dotnet meta gen` (C#), `metaobjects
+   gen` (Python), `mvn metaobjects:generate` (Java and Kotlin). `verify --codegen` (Maven:
+   `metaobjects:verify`) regenerates the same list and diffs it.
+3. Nothing is generated that the list does not declare. There is no default set of
+   generators, documentation included.
+4. There is no docs command, no docs goal, no docs marker on a generator, no logic in a gen
+   command that skips documentation, and no second list.
+5. A gen command's `--generators <names>` flag (TypeScript, C#, Python) narrows a run to
+   declared entries, by registry name. It never adds a generator the list does not declare;
+   naming one is refused. This is how a project writes its documentation without its code.
+   Maven does the same natively: a second `<execution>` of `generate` with its own
+   `<generators>`, run as `mvn metaobjects:generate@<execution-id>`.
+
+**Where the list is, per port.**
+
+| Port | The list | Scaffolded by |
+|---|---|---|
+| TypeScript | `generators` in `metaobjects.config.ts`; output locations are `targets` | `meta init` |
+| C# | `codegen/Generators.cs`: a static list of constructed generators with their options as init properties. `codegen/Program.cs` is a two-line entry point that passes that list to `CodegenCli.Run` | `dotnet meta init` (new in 1.1.0); `dotnet meta eject` writes the three files when missing |
+| Python | `targets.<name>.generators` in `metaobjects.config.yaml`, each target with its `outDir`; a generator's options are a top-level block named for it (the `requirementTests` precedent) | the adopter; the port has no `init`, and the migration section shows the file |
+| Java, Kotlin | `<generators>` in the `metaobjects-maven-plugin` `<configuration>`, one `<generator>` per entry with its options in `<args>` | the adopter's pom; unchanged from 1.0 |
+
+**Inputs that were docs flags, per port.** Each row is an option of a list entry now.
+
+| Former input | TypeScript | C# (`ApiDocsGenerator` init property) | Python | Java, Kotlin (`<args>` of the api-docs entry) |
+|---|---|---|---|---|
+| Output directory (`--out`, `docs.outDir`, `<outputDirectory>`) | `targets.docs.outDir` | `OutDir` | `targets.<name>.outDir` of the target that lists `api-docs` | `outputDir` |
+| Page layout (`--layout`, `docs.layout`, `<layout>`) | `targets.docs.outputLayout` | none: C# writes `package` | none: Python writes `package` | `layout` (`flat` or `package`, default `flat`) |
+| API sub-directory (`--api-subdir`, `<apiSubDir>`) | `apiDocsFile({ subDir })` | `ApiSubDir` | `apiDocs.apiSubDir` | `apiSubDir` (default `api/java`, Kotlin `api/kotlin`) |
+| Project label (`--project`, `<projectName>`) | `apiDocsFile({ projectName })` | `ProjectName` | `apiDocs.projectName` | `projectName` |
+| Model back-link base (`--model-base-url`, `--base-url`, `docs.baseUrl`, `<modelBaseUrl>`) | `modelBaseUrl` on `docsFile()` and `apiDocsFile()` | `ModelBaseUrl` | `apiDocs.modelBaseUrl` | `modelBaseUrl` |
+| Which surfaces (`--model`, `--api`, `--requirements`, `--agent`, `docs.surfaces`, `<language>`) | which factories are listed: `docsFile()`, `apiDocsFile()`, `requirementsFile()`, `agentDocsFile()` | whether `ApiDocsGenerator` is listed | whether `api-docs` is listed | which class is listed: `JavaApiDocsGenerator`, `KotlinApiDocsGenerator`, or both |
+| Other ports' api pages to link (`docs.apiSurfaces`) | `docsFile({ apiSurfaces })` | n/a | n/a | n/a |
+| Template overrides (`--templates`) | `docsFile({ templates })` | n/a | n/a | n/a |
+| Owned docs generators (`docs.generators`) | the owned copy in `generators`, like any other | the owned copy in `Generators.cs` | the owned module in a target's `generators` | the owned class in `<generators>` |
+| Metadata providers (`--provider`) | n/a | n/a | top-level `providers` (already there) | n/a |
+
+The C# namespace the api pages cite stays the gen run's `--namespace`, as today.
+
+**TypeScript work that had no generator.** `meta docs` did two things that were not
+generators, and both become one:
+
+- `--metamodel` (the reference of the built-in vocabulary) becomes `metamodelDocsFile()`,
+  registry name `metamodel-docs`, ejectable like the rest.
+- `--site` (the HTML site) becomes `docsSiteFile({ prompts })`, registry name `docs-site`.
+  Its builder stays packaged under Amendment 8 ruling 3, and its manifest exemption now
+  reads: the builder is engine; what an adopter changes is the site's templates and
+  assets. `--scaffold-site`, which copied those, becomes `meta eject docs-site`, which
+  copies the same files to the same place (`codegen/docs-site/`).
+
+Docs factories default to `target: "docs"`. A run that lists one while `targets` has no
+`docs` entry is refused, naming the generator and the missing target: documentation is
+never written into the code's output directory by default. The cross-link facts the docs
+door used to build (`ctx.docsDoor`) are built by the runner from the declared entries,
+so the model and api pages still agree on where each other is.
+
+`meta agent-docs`, `meta init --refresh-docs` and their C# and Python counterparts are not
+documentation of the model. They install the agent-context files and are unchanged.
+
+**Messages.** The text is fixed. Each removed command exits non-zero (2) after printing its
+line. `<section>` is `TypeScript`, `C#`, `Python` or `Java and Kotlin`.
+
+A removed docs command or goal prints:
+
+```
+<removed> was removed in <version>. `<gen>` writes documentation now: declare each docs generator <where>. See docs/features/migrations/docs-are-generators.md, section "<section>".
+```
+
+| Port | `<removed>` | `<version>` | `<gen>` | `<where>` |
+|---|---|---|---|---|
+| TypeScript | `meta docs` | 1.1.0 | `meta gen` | in `generators` in metaobjects.config.ts |
+| C# | `dotnet meta docs` | 1.1.0 | `dotnet meta gen` | in codegen/Generators.cs |
+| Python | `metaobjects docs` | 1.1.0 | `metaobjects gen` | in a target's `generators` in metaobjects.config.yaml |
+| Java, Kotlin | `metaobjects:docs` | 8.1.0 | `mvn metaobjects:generate` | as a <generator> entry in the plugin's <generators> |
+
+The Java and Kotlin line, exactly, as `DocsMojo` prints it:
+
+```
+metaobjects:docs was removed in 8.1.0. `mvn metaobjects:generate` writes documentation now: declare each docs generator as a <generator> entry in the plugin's <generators>. See docs/features/migrations/docs-are-generators.md, section "Java and Kotlin".
+```
+
+TypeScript `meta verify --docs` prints:
+
+```
+`meta verify --docs` was removed in 1.1.0. `meta verify --codegen` checks documentation now, with everything else `generators` declares. See docs/features/migrations/docs-are-generators.md, section "TypeScript".
+```
+
+A gen command given a 1.0-shape config fails before it writes anything. It never runs and
+writes nothing silently. It prints:
+
+```
+<gen>: found 1.0 docs configuration (<what>). Nothing reads it any more, so this run would write no documentation. Declare each docs generator <where>. See docs/features/migrations/docs-are-generators.md, section "<section>".
+```
+
+`<gen>` here is the command's own name (`meta gen`, `dotnet meta gen`, `metaobjects gen`,
+`metaobjects:generate` or `metaobjects:verify`). What counts as 1.0 shape, and `<what>`:
+
+| Port | 1.0 shape | `<what>` |
+|---|---|---|
+| TypeScript | a `docs` key in the config | `the docs block in metaobjects.config.ts` |
+| C# | `--project` or `--model-base-url` passed to `gen` | the flags given, e.g. `--project` |
+| Python | a top-level `docs` key in the config | `the docs block in metaobjects.config.yaml` |
+| Java, Kotlin | `<language>`, `<apiSubDir>`, `<layout>` or `<modelBaseUrl>` in the plugin's `<configuration>` | the elements found, then ` in the plugin's <configuration>` |
+
+A gen command with no list at all fails too, for the same reason:
+
+| Port | Case | Message |
+|---|---|---|
+| TypeScript | no `metaobjects.config.ts` | `meta gen: no metaobjects.config.ts. Nothing is generated until a config declares it, documentation included; \`meta init\` writes one. A 1.0 project that ran \`meta docs\` with no config: see docs/features/migrations/docs-are-generators.md, section "TypeScript".` |
+| C# | no `codegen/Generators.cs` | `dotnet meta gen: no codegen/Generators.cs. The generator list lives there in 1.1.0, documentation included; \`dotnet meta init\` writes it. See docs/features/migrations/docs-are-generators.md, section "C#".` |
+| Python | no `metaobjects.config.yaml` | `metaobjects gen: no metaobjects.config.yaml. The generator list lives there in 1.1.0, documentation included. See docs/features/migrations/docs-are-generators.md, section "Python".` |
+| Java, Kotlin | no `<generators>` | unchanged: the goal runs nothing, as in 1.0, because a pom that binds the goal and lists nothing is a declaration Maven reads literally |
+
+A list that is present and empty is not an error. It writes nothing and says so, as today.
+
+**The migration section.** `docs/features/migrations/docs-are-generators.md` has one
+section per port, headed exactly `TypeScript`, `C#`, `Python`, `Java and Kotlin`. Each
+section is written for a coding agent to apply by hand to an adopter's config, with no tool:
+
+1. What the 1.0 project has: the command or goal it runs, and its config, as a literal
+   before block.
+2. The same project in 1.1.0, as a literal after block that writes the same pages to the
+   same paths.
+3. A table from each 1.0 flag, key or element to its new option (the table above, for that
+   port).
+4. What to change in scripts and CI: the docs command becomes the gen command, and a run
+   meant to write only documentation passes `--generators` with the docs entries' names
+   (Maven: a second execution).
+5. TypeScript only: the no-config case. A project that ran `meta docs` with no
+   `metaobjects.config.ts` writes one, with a `docs` target and `docsFile()`, and nothing
+   else.
+
+No upgrade script exists and none is to be built. `meta upgrade --apply` does not rewrite
+generator configs.
+
+**Java and Kotlin: what this change does.** `DocsGenerator` (the marker), the skips in
+`metaobjects:generate` and `metaobjects:verify`, and the docs goal's body are deleted.
+`JavaApiDocsGenerator` and `KotlinApiDocsGenerator` are ordinary generators that read
+`outputDir`, `apiSubDir`, `layout`, `projectName` and `modelBaseUrl` from `<args>`. The
+`docs` goal is kept only to print the line above, because Maven's own error for a missing
+goal names neither the replacement nor the migration section. `metaobjects:verify`
+regenerates an api-docs entry's `outputDir` like any other; give it a directory that holds
+generated files only.
+
+**Java `entity` writes no `<Name>Extractor`.** In 1.0 the `entity` generator also wrote an
+extractor class per object unless the pom listed `extractor`: output the pom did not
+declare. The `extractor` generator is now the one entry that writes extractors. A pom that
+listed only `entity` and used the extractors adds:
+
+```xml
+<generator>
+  <classname>com.metaobjects.generator.direct.object.javacode.ExtractorCodeGenerator</classname>
+  <args><outputDir>(the entity entry's outputDir)</outputDir></args>
+</generator>
+```
+
+with the same naming args and `<filters>` as the `entity` entry, so each extractor lands
+beside its class. `EmitsObjectExtractors` and the plugin's derivation of it are removed;
+neither was something a pom could name.
+
+**A config that declares nothing writes nothing**, and each port has a test that says so:
+an empty list, run through the port's gen command or goal, writes zero files. Java and
+Kotlin have it in this change (`DeclaresNothingWritesNothingTest`); the other ports add it
+with their change.
+
+**Supersedes.**
+
+- **Amendment 7**, the docs door's seam: the `docs.generators` list, the `docsSurface`
+  marker, the skip in `meta gen`, `ctx.docsDoor` as a door's context, and `meta eject`
+  printing `docs: { generators: [...] }`. An owned docs copy is wired into `generators`
+  like every other owned copy, and `meta eject` prints that entry. Amendment 7's rulings on
+  `shared-model`, `mermaid-er` and `template` stand.
+- **ADR-0021 D1** and **ADR-0022 Part 2 D1**: documentation is reached through the gen
+  command, not kept out of it. Part 3's dividing test (neutral model pages against the
+  per-port api reference) stands as a description of two generators.
+- **ADR-0025 D1, D2's defaults, D4 and the per-port commands of D5**: there is no docs
+  door. The output tree and the cross-link contract of D2, D3 and D5 stand; they are now
+  produced by the declared entries.
+- **Amendment 8, the `DocsGenerator` names in the Java and Kotlin engine lists** (the class
+  is gone), and **ruling 3's "not a generator"** for the TypeScript site (it is the
+  `docs-site` entry above).
+
+**Version.** This ships in 1.1.0 (Maven 8.1.0). Removing a published command is a major by
+`docs/compatibility-policy.md`; the number is the maintainer's explicit override of that
+policy for this release, recorded here so the CHANGELOG's breaking notice can cite it.
+
+**Open.** Nothing. The C# file name was ruled 2026-10-14: the list lives in
+`codegen/Generators.cs`, and `codegen/Program.cs` is a two-line entry point.