diff --git a/CHANGELOG.md b/CHANGELOG.md
index 514b4743a..a9c9953e6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -60,6 +60,39 @@ generator catalog and the Atlas evaluation are 1.2 work.
 
 ### Added
 
+- **The Java `entity` and `extractor` generators can be ejected.**
+  `mvn metaobjects:eject -Dnames=entity,extractor -Dport=java` copies each generator, with
+  the rest of its emit, into your `codegen/` module. They were the two Java generators that
+  could not be owned: `entity`'s class body is emitted by writer classes outside the
+  generator, and `extractor` was a step inside `entity` that no `<generator>` entry could
+  name. Unchanged copies emit what the packaged generator emits, `-Dlist` marks them
+  `identical` or `DIFFERS`, and `mvn metaobjects:verify` runs them when your pom names them.
+  Every Java generator is now ejectable except `template`. Ruling and reasoning: ADR-0034
+  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
+    (`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
+    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`,
+    `GeneratorRegistry.GeneratorInfo.ejectWith()`, the classes eject copies with a
+    generator.
+
 - **Agent skills: a cost test for owned generators.** The `metaobjects-codegen` skill now says when not to write a generator: only when generator code plus
   its generated output and added metadata is fewer lines than the hand-written code it
   replaces, more instances of the shape are expected, or drift protection is the
@@ -445,6 +478,24 @@ until you regenerate.
 
 ### Changed
 
+- **Java classes written by `entity` lose two header lines, and `mvn metaobjects:verify` no
+  longer depends on the clock.** The header comment of every class `JavaObjectCodeGenerator`
+  writes carried `ObjectCodeWriter:` (the writer's class name) and `Generated On:` (the
+  wall-clock second of the run). Both lines are removed. **Expect a one-time diff in every
+  regenerated Java class file, in the header comment only.** The timestamp meant
+  `mvn metaobjects:verify`, which compares bytes, reported `[content-differs]` for every
+  class file unless it ran in the same second as the generate it checked. Generated output
+  now holds nothing that varies between runs, so regenerating an unchanged model writes the
+  same bytes and verify passes whenever it runs. The writer's class name is dropped, not
+  replaced by a stable name: it would differ between a packaged writer and an owned copy of
+  it, and dropping the line is the smaller change.
+- **`mvn metaobjects:eject -Dnames=entity` and `-Dnames=extractor` need a port when the
+  project does not imply one.** Both names are now ejectable on Java and on Kotlin. A
+  project that declares exactly one of `metaobjects-codegen-spring` and
+  `metaobjects-codegen-kotlin` is unaffected, because the goal infers the port from it.
+  With neither or both declared, the goal used to resolve these two names to Kotlin, the
+  only port that had them; it now refuses with `ejectable on more than one port` and asks
+  for `-Dport=java|kotlin`, as it already did for `names` and `requirement-tests`.
 - **TypeScript: `RequirementTestArgs` and `RequirementView` gained required fields — a
   compile break for code that builds them by hand.** `RequirementTestArgs` has six new
   required fields (`package`, `unit`, `id`, `witnessKey`, `skip`, `digest`) and
diff --git a/README.md b/README.md
index 2ce6d7795..d078fd2d9 100644
--- a/README.md
+++ b/README.md
@@ -159,7 +159,7 @@ first-week wedge plan — and `meta init` picks up from there.
 | Metadata dependencies (`dependencies`) | Yes (`meta deps sync`, `path` transport) | Phase 2 | Phase 2 | Phase 2 | Yes (loads the synced snapshot) |
 | Runtime metadata (ObjectManager-style) | Yes (`runtime-ts`) | Yes (OMDB) | Yes (via Java OMDB + Exposed) | Roadmap | Yes (ObjectManager) |
 | React / Angular UI client (browser) | React: **published** (`@metaobjectsdev/react` + `@metaobjectsdev/tanstack`), codegen + runtime. Angular 18: **source-only by decision** ([ADR-0048](spec/decisions/ADR-0048-angular-tier-source-only.md)) — `@metaobjectsdev/angular` + `@metaobjectsdev/codegen-ts-angular` build in-repo on their own `0.6.x` line but are deliberately not on npm (`npm i @metaobjectsdev/angular` will 404) until they meet the ADR's promotion bar. Consume them from source. | Consumes TS client via REST | Consumes TS client via REST | Consumes TS client via REST | Consumes TS client via REST |
-| Own a generator (`eject`) | Yes (`meta eject`) | Yes (`mvn metaobjects:eject`; `entity` is not ejectable) | Yes (`mvn metaobjects:eject`) | Yes (`dotnet meta eject`) | Yes (`metaobjects eject`) |
+| Own a generator (`eject`) | Yes (`meta eject`) | Yes (`mvn metaobjects:eject`) | Yes (`mvn metaobjects:eject`) | Yes (`dotnet meta eject`) | Yes (`metaobjects eject`) |
 | Cross-port REST routes for the client (reference generators) | Generated (`routesFile()` → Fastify) | Generated (`SpringControllerGenerator` → Spring `@RestController`, incl. filter/sort) | Generated (`KotlinSpringControllerGenerator` → Spring `@RestController`, incl. filter/sort) | Generated (`RoutesGenerator` → ASP.NET Minimal API) | Generated (`router_generator` → FastAPI `APIRouter`, incl. filter/sort) |
 
 A "Yes" means the feature is covered by the shared conformance corpora at
diff --git a/agent-context/skills/metaobjects-codegen/references/java.md b/agent-context/skills/metaobjects-codegen/references/java.md
index 0f2a615e4..bdfd52171 100644
--- a/agent-context/skills/metaobjects-codegen/references/java.md
+++ b/agent-context/skills/metaobjects-codegen/references/java.md
@@ -159,7 +159,21 @@ 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 `<Name>Extractor` plus a self-registering `ObjectClassBindingProvider`. For a plain default-Jackson-friendly type, use the `codegen-spring` record surface instead — never `pojoAware`. |
+| `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. |
+
+**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
+required: both names are ejectable on both JVM ports). For `entity` that is seven files in
+one package: `JavaObjectCodeGenerator` (flavor selection, `createWriter`, the binding
+provider source and its `META-INF/services` registration), the bases it extends
+(`JavaCodeGenerator`, `BaseObjectCodeGenerator`), and the writers that emit the class body
+(`BaseObjectCodeWriter`, `JavaCodeWriter`, `PojoAwareCodeWriter`, `ValueObjectCodeWriter`).
+The copies use one another, not the packaged classes. To change a field, a constructor or
+an accessor, edit the owned writer; do not subclass a packaged one. `extractor` copies
+`ExtractorCodeGenerator` with `JavaCodeWriter` and `BaseObjectCodeWriter`, and shares them
+with `entity` when both are in one package. Every Java generator can be ejected except
+`template`.
 
 **Projections (read-only views).** An `object.projection` (read-only `source.rdb`
 `@kind: view` child) is served read-only through OMDB at the ObjectManager layer
diff --git a/docs/features/own-your-codegen.md b/docs/features/own-your-codegen.md
index 2938e9472..03534b46e 100644
--- a/docs/features/own-your-codegen.md
+++ b/docs/features/own-your-codegen.md
@@ -518,7 +518,9 @@ 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`). The package declaration is the only line it changes. On first use
+`<groupId>.codegen`). The package declaration is the only line it changes, except for a
+generator that is copied with other classes (Java `entity` and `extractor`, 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.
 
@@ -536,6 +538,69 @@ from which the goal infers it. `requirement-tests` is one such name:
 `KotlinRequirementTestsGenerator.kt`, each with its default rendering. The identity
 function, the digest and the renderer and filter hook types stay in the package.
 
+### Java `entity` and `extractor`
+
+```bash
+mvn metaobjects:eject -Dnames=entity,extractor -Dport=java
+```
+
+Both names exist in both ports, so pass `-Dport`. Their reference source ships in
+`metaobjects-codegen-base`, not `metaobjects-codegen-spring`; your `codegen/` module
+reaches it through the same dependency.
+
+**`entity` copies seven files, and together they are the generator.**
+`JavaObjectCodeGenerator` does not emit a class body itself. A writer does, one per
+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. |
+| `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. |
+| `PojoAwareCodeWriter`, `ValueObjectCodeWriter` | The fields, the constructor and the accessor bodies of the two concrete flavors. |
+
+All seven land in one package and use one another, never the packaged classes: eject
+rewrites the package line of each and, where one imports another, that import. To change a
+field, a constructor or an accessor, edit the writer. You subclass nothing. `-Dlist` gives
+`entity` one verdict over all seven files.
+
+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.
+
+**`extractor` copies three files.** `ExtractorCodeGenerator.java` holds its emit.
+`JavaCodeWriter` and `BaseObjectCodeWriter` come with it because that is where it reads the
+package and class name of the type each extractor casts to. Eject both generators into the
+same package, which is the default, and they share the one `JavaCodeWriter`: a naming
+change made there moves the classes and their extractors together.
+
+`extractor` is a generator of its own: add it to `<generators>` with the same `outputDir`,
+`pkgPrefix`, `pkgSuffix`, `namePrefix` and `nameSuffix` as your `entity` generator, and the
+same `<filters>` if that one has any. An extractor casts to the generated flavored class,
+so `entity` with a concrete `flavor` has to be in the same run and has to select the same
+objects: an extractor for an object `entity` wrote no class for does not compile.
+
+```xml
+<generator>
+  <classname>com.acme.codegen.ExtractorCodeGenerator</classname>
+  <args><outputDir>${project.build.directory}/generated-sources/metaobjects</outputDir></args>
+</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.
+
+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.
+
 ### What eject hands over, and what stays core
 
 An owned generator is only yours if the code its output depends on is yours too. The Java
@@ -608,13 +673,16 @@ diff -u -I '^package ' -I '^// metaobjects:owned-runtime' \
 
 Apply the hunks you want by hand. For a generator, diff `reference/java/<Generator>.java`
 against `codegen/src/main/java/<package>/<Generator>.java` the same way, and also ignore
-`RUNTIME_PACKAGE`. Or, if you have no edits of your own (`-Dlist` says `identical`),
-re-eject with `-Dforce`.
+`RUNTIME_PACKAGE`. `entity` and `extractor`, and the classes copied with them, are in
+`metaobjects-codegen-base-$V.jar` instead; for those also pass `-I '^import '`, because
+eject pointed the copies' imports of one another at your package. Or, if you 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. In Java, `entity`, `extractor` and
-`template` are not: `entity` shares internal writer classes with `extractor`, and
-`template` is the Mustache primitive, which has no emit logic of its own to own.
+do not say which. Every Kotlin generator is ejectable, and every Java generator except
+`template`. `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 d03257fb9..97a068672 100644
--- a/docs/ports/java.md
+++ b/docs/ports/java.md
@@ -281,11 +281,11 @@ 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 `<Name>Extractor` and a self-registering `ObjectClassBindingProvider`. 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`, 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`. |
 | `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` wrapping the runtime tolerant extract, turning dirty LLM text into a fully-typed flavored object graph (nested objects + arrays-of-objects populated) in one call. 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. |
+| `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. |
 
@@ -294,11 +294,17 @@ Every one is independently configurable; the typical starting set is
 `SpringControllerGenerator` + `SpringDtoGenerator` + `SpringRepositoryGenerator`
 (controller + DTO + repository).
 
-**One exception: `extractor` is not separately wirable on this port.** It is emitted by
-`entity` — `JavaObjectCodeGenerator` runs `ExtractorCodeGenerator` for every non-abstract
-object it emits — so its output ships whenever `entity` is in your `<generators>`, and
-there is no `<generator>` entry for it. The other four ports expose `extractor` as a
-standalone generator; Java fuses it, which is why it carries a stable name here at all.
+**`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.
 
 ### Reports
 
@@ -517,7 +523,11 @@ 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).
+**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`.
+
+**`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).
+
+**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.
 
 **Ejecting hands over the helper runtime too.** The `routes`, `dto` and `repository` output imports helper classes from `com.metaobjects.generator.spring.runtime` (`FilterParser`, `FilterParseResult`, `FilterPredicate`, `PatchValidationException`, `ConstraintErrors`, `RecordComponentNames`). These are helpers, not core. Ejecting one of those generators copies the classes its output imports into `src/main/java/<runtimePackage>/` (default `<groupId>.runtime`) of the module that compiles the generated code, and the owned generator's output imports that copy. The copies are JDK-only. The owned web tier then builds with no MetaObjects artifact on the application classpath, and you can fix a helper bug in your copy without waiting for a release. A packaged generator that must use the same copy takes `<args><runtimePackage>…</runtimePackage></args>`. What stays core: the loader and registry, render and extract, OMDB and `metaobjects-om`. `mvn metaobjects:verify` treats the copies as owned code, not stale output. The table, the aggregator rule and a diff recipe for pulling an upstream fix are in [Own your codegen → What eject hands over](../features/own-your-codegen.md#what-eject-hands-over-and-what-stays-core).
 
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 0f2a615e4..bdfd52171 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
@@ -159,7 +159,21 @@ 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 `<Name>Extractor` plus a self-registering `ObjectClassBindingProvider`. For a plain default-Jackson-friendly type, use the `codegen-spring` record surface instead — never `pojoAware`. |
+| `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. |
+
+**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
+required: both names are ejectable on both JVM ports). For `entity` that is seven files in
+one package: `JavaObjectCodeGenerator` (flavor selection, `createWriter`, the binding
+provider source and its `META-INF/services` registration), the bases it extends
+(`JavaCodeGenerator`, `BaseObjectCodeGenerator`), and the writers that emit the class body
+(`BaseObjectCodeWriter`, `JavaCodeWriter`, `PojoAwareCodeWriter`, `ValueObjectCodeWriter`).
+The copies use one another, not the packaged classes. To change a field, a constructor or
+an accessor, edit the owned writer; do not subclass a packaged one. `extractor` copies
+`ExtractorCodeGenerator` with `JavaCodeWriter` and `BaseObjectCodeWriter`, and shares them
+with `entity` when both are in one package. Every Java generator can be ejected except
+`template`.
 
 **Projections (read-only views).** An `object.projection` (read-only `source.rdb`
 `@kind: view` child) is served read-only through OMDB at the ObjectManager layer
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 0f2a615e4..bdfd52171 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
@@ -159,7 +159,21 @@ 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 `<Name>Extractor` plus a self-registering `ObjectClassBindingProvider`. For a plain default-Jackson-friendly type, use the `codegen-spring` record surface instead — never `pojoAware`. |
+| `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. |
+
+**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
+required: both names are ejectable on both JVM ports). For `entity` that is seven files in
+one package: `JavaObjectCodeGenerator` (flavor selection, `createWriter`, the binding
+provider source and its `META-INF/services` registration), the bases it extends
+(`JavaCodeGenerator`, `BaseObjectCodeGenerator`), and the writers that emit the class body
+(`BaseObjectCodeWriter`, `JavaCodeWriter`, `PojoAwareCodeWriter`, `ValueObjectCodeWriter`).
+The copies use one another, not the packaged classes. To change a field, a constructor or
+an accessor, edit the owned writer; do not subclass a packaged one. `extractor` copies
+`ExtractorCodeGenerator` with `JavaCodeWriter` and `BaseObjectCodeWriter`, and shares them
+with `entity` when both are in one package. Every Java generator can be ejected except
+`template`.
 
 **Projections (read-only views).** An `object.projection` (read-only `source.rdb`
 `@kind: view` child) is served read-only through OMDB at the ObjectManager layer
diff --git a/server/java/codegen-base/pom.xml b/server/java/codegen-base/pom.xml
index 7af0508bf..7d585377d 100644
--- a/server/java/codegen-base/pom.xml
+++ b/server/java/codegen-base/pom.xml
@@ -91,7 +91,58 @@
                     </execution>
                 </executions>
             </plugin>
-            
+
+            <!-- `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, and com.metaobjects.generator.GeneratorRegistry.EJECT_RESOURCE_ROOT).
+                 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
+                 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"
+                 (TemplateScopeGenerator) is not shipped: it is the Mustache primitive and
+                 has no emit logic of its own. -->
+            <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/object/javacode</directory>
+                                    <includes>
+                                        <include>JavaObjectCodeGenerator.java</include>
+                                        <include>ExtractorCodeGenerator.java</include>
+                                        <include>JavaCodeGenerator.java</include>
+                                        <include>JavaCodeWriter.java</include>
+                                        <include>PojoAwareCodeWriter.java</include>
+                                        <include>ValueObjectCodeWriter.java</include>
+                                    </includes>
+                                </resource>
+                                <resource>
+                                    <directory>src/main/java/com/metaobjects/generator/direct/object</directory>
+                                    <includes>
+                                        <include>BaseObjectCodeGenerator.java</include>
+                                        <include>BaseObjectCodeWriter.java</include>
+                                    </includes>
+                                </resource>
+                            </resources>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+
         </plugins>
     </build>
 </project>
\ No newline at end of file
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
new file mode 100644
index 000000000..fabd25c7c
--- /dev/null
+++ b/server/java/codegen-base/src/main/java/com/metaobjects/generator/EmitsObjectExtractors.java
@@ -0,0 +1,52 @@
+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/object/BaseObjectCodeWriter.java b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/object/BaseObjectCodeWriter.java
index 65dadceb6..c722fdb4f 100644
--- a/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/object/BaseObjectCodeWriter.java
+++ b/server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/object/BaseObjectCodeWriter.java
@@ -218,11 +218,9 @@ public String writeObject(MetaObject mo) throws GeneratorIOException {
             // Deleting this line is the documented gesture for taking ownership of the file.
             List<String> docs = Arrays.asList(
                     "GENERATED — regenerated from metadata. Delete this line to own this file.",
-                    "ObjectCodeWriter:         " + getClass().getName(),
                     "MetaObject:               " + mo.getName(),
                     "SuperObject:              " + (superObject != null ? superObject.getName() : ""),
                     "MetaDataLoader:           " + getLoader().toString(),
-                    "Generated On:             " + (new Date()).toString(),
                     "Context:                  " + (context != null ? "initialized" : "null")
             );
             
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 50833c3ea..ae3e244c5 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
@@ -1,9 +1,22 @@
 package com.metaobjects.generator.direct.object.javacode;
 
+// 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;
 import com.metaobjects.generator.util.GeneratedFileWriter;
+import com.metaobjects.generator.util.GeneratorUtil;
+import com.metaobjects.io.util.IOUtil;
+import com.metaobjects.loader.MetaDataLoader;
+import com.metaobjects.object.MetaObject;
 
 import java.io.File;
 import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
 
 /**
  * Emits a generated {@code <Name>Extractor} — the Task-6 payoff that wraps the Phase-B
@@ -33,12 +46,24 @@
  * flavored type. The {@code extractLenient(...)} overload widens through {@code ExtractionResult<?>}
  * to expose the typed {@code ExtractionResult<<Type>>}.</p>
  *
- * <p>This is a plain emission helper (direct {@code StringBuilder} emit; no templates) driven
- * by {@link JavaObjectCodeGenerator#execute}. Its emission steps are {@code protected} so a
- * downstream generator can override one step (e.g. {@link #writeExtractMethod}) without
- * reimplementing the whole class.</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>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
+ * both generators the same {@code <filters>}. An Extractor for an object {@code entity} wrote
+ * no class for does not compile.</p>
+ *
+ * <p>Emission is a direct {@code StringBuilder} emit (no templates). Its steps are
+ * {@code protected} so a subclass can override one (e.g. {@link #writeExtractMethod})
+ * without reimplementing the whole class.</p>
  */
-public class ExtractorCodeGenerator {
+public class ExtractorCodeGenerator extends GeneratorBase implements EmitsObjectExtractors {
 
     /** Fully-qualified name of the runtime extract entry point (emitted as a source FQN string). */
     public static final String META_OBJECT_EXTRACT_FQN =
@@ -54,6 +79,46 @@ public class ExtractorCodeGenerator {
     /** Suffix appended to the flavored class's simple name to form the Extractor class name. */
     public static final String EXTRACTOR_SUFFIX = "Extractor";
 
+    /**
+     * Write one {@code <Name>Extractor} per concrete object the filters select. Abstract
+     * objects get none: {@code MetaObject.newInstance()} cannot build one, so an extractor
+     * for it could never return a typed graph.
+     */
+    @Override
+    public void execute(MetaDataLoader loader) {
+        if (!hasArg(ARG_OUTPUTDIR)) {
+            throw new GeneratorException(
+                    "You must set a valid output directory with arg '" + ARG_OUTPUTDIR + "'");
+        }
+        File outputDir = getOutputDir();
+        JavaCodeWriter namer = createNamer(loader);
+        try {
+            for (MetaObject mo : GeneratorUtil.getFilteredMetaData(
+                    loader, MetaObject.class, getMetaDataFilters())) {
+                if (IOUtil.isAbstract(mo)) {
+                    continue;
+                }
+                emit(outputDir, namer.getLanguagePackage(mo), namer.getClassName(mo), mo.getName());
+            }
+        } catch (IOException e) {
+            throw new GeneratorException("Unable to emit generated Extractor: " + e, e);
+        }
+    }
+
+    /**
+     * The writer whose naming hooks say which package and class each Extractor sits beside.
+     * It names; it never writes. It has to be the writer your {@code entity} generator names
+     * its classes through, so both agree: ejected into one package, the two share one copy.
+     */
+    protected JavaCodeWriter createNamer(MetaDataLoader loader) {
+        JavaCodeWriter namer = new JavaCodeWriter(loader, new PrintWriter(new StringWriter()));
+        namer.withPkgPrefix(getArg(BaseObjectCodeGenerator.ARG_PKGPREFIX, ""))
+             .withPkgSuffix(getArg(BaseObjectCodeGenerator.ARG_PKGSUFFIX, ""))
+             .withNamePrefix(getArg(BaseObjectCodeGenerator.ARG_NAMEPREFIX, ""))
+             .withNameSuffix(getArg(BaseObjectCodeGenerator.ARG_NAMESUFFIX, ""));
+        return namer;
+    }
+
     /**
      * Emit {@code <className>Extractor.java} into {@code outputDir} under the package directory
      * derived from {@code javaPackage}.
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 6b73ce019..8dc07b625 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
@@ -1,5 +1,13 @@
 package com.metaobjects.generator.direct.object.javacode;
 
+// 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;
 import com.metaobjects.generator.GeneratorException;
 import com.metaobjects.generator.direct.GenerationContext;
 import com.metaobjects.generator.direct.object.BaseObjectCodeWriter;
@@ -13,6 +21,7 @@
 import java.io.File;
 import java.io.IOException;
 import java.io.PrintWriter;
+import java.io.StringWriter;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.util.Collection;
@@ -33,6 +42,16 @@
  * emission loop (which already iterates EVERY {@code MetaObject} in the loader, so the
  * nested sub-objects referenced via {@code @objectRef} are emitted as their own files) —
  * is inherited unchanged from the legacy framework.</p>
+ *
+ * <p><b>Owning this generator</b> ({@code mvn metaobjects:eject -Dnames=entity -Dport=java},
+ * ADR-0034 Amendment 6). The copy is this file and the rest of its emit, in one package:
+ * {@link JavaCodeGenerator} and {@code BaseObjectCodeGenerator} (arguments, and where each
+ * file lands), and the writers that emit the class body ({@code BaseObjectCodeWriter},
+ * {@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>
  */
 public class JavaObjectCodeGenerator extends JavaCodeGenerator {
 
@@ -58,6 +77,16 @@ 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";
@@ -99,7 +128,9 @@ 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}.
+     * 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.
      */
     @Override
     public void execute(MetaDataLoader loader) {
@@ -113,9 +144,9 @@ public void execute(MetaDataLoader loader) {
         // to its generated fully-qualified Java class name, reusing the SAME naming hooks
         // the writer used so the binding targets the class that was actually emitted.
         JavaCodeWriter namer = (JavaCodeWriter)
-                createWriter(loader, null, new PrintWriter(new java.io.StringWriter()), globalContext);
+                createWriter(loader, null, new PrintWriter(new StringWriter()), globalContext);
         Map<String, String> fqnToClass = new LinkedHashMap<>();
-        ExtractorCodeGenerator extractorGen = new ExtractorCodeGenerator();
+        ExtractorCodeGenerator extractorGen = emitsExtractors() ? new ExtractorCodeGenerator() : null;
         Collection<MetaObject> metadata =
                 GeneratorUtil.getFilteredMetaData(loader, getFilterClass(), getMetaDataFilters());
         try {
@@ -134,7 +165,9 @@ public void execute(MetaDataLoader loader) {
                 // 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.
-                extractorGen.emit(getOutputDir(), javaPkg, javaClass, mo.getName());
+                if (extractorGen != null) {
+                    extractorGen.emit(getOutputDir(), javaPkg, javaClass, mo.getName());
+                }
             }
         } catch (IOException e) {
             throw new GeneratorException("Unable to emit generated Extractor: " + e, e);
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 86a8c3590..6124c8564 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
@@ -26,6 +26,11 @@ For each concrete flavor, the generator also emits, per object:
   `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).
+
 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).
 
@@ -51,6 +56,35 @@ generator (override `createWriter` to return its writer). Proven by
 `DownstreamCustomizationTest` (overrides `getGetterMethodName` → `fetch<Name>()` via a
 `createWriter` override, compiled + asserted).
 
+## Owning the generators (`mvn metaobjects:eject`)
+
+`JavaObjectCodeGenerator` (`entity`) and `ExtractorCodeGenerator` (`extractor`) eject into
+the adopter's `codegen/` module, each with the rest of its emit (ADR-0034 Amendment 6).
+This module's pom ships the sources under `META-INF/metaobjects/reference/java/`, and
+`GeneratorRegistry` (in `codegen-spring`) declares which classes go with which generator.
+
+| Generator | Copied with it, into the same owned package |
+|---|---|
+| `entity` | `JavaCodeGenerator`, `BaseObjectCodeGenerator`, `BaseObjectCodeWriter`, `JavaCodeWriter`, `PojoAwareCodeWriter`, `ValueObjectCodeWriter` |
+| `extractor` | `JavaCodeWriter`, `BaseObjectCodeWriter` |
+
+Eject rewrites each file's package line and, where one copied class imports another, that
+import. So the owned generator extends and calls the owned copies: an adopter changes the
+class body by editing a writer, not by subclassing one. What a copy may still rely on in
+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.
+
+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
+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.
+
 ## Deviation list (what is NOT reused as-is, and why)
 
 The default is reuse; these are the accounted-for exceptions.
@@ -76,6 +110,9 @@ The default is reuse; these are the accounted-for exceptions.
    `MetaObject` already in the loader, so the inherited flat multi-file loop emits every
    referenced sub-object exactly once — no visited-set/cycle guard needed (the spec's
    recursive-emission note is superseded by this simpler sound behavior).
+6. **Class header (changed).** `BaseObjectCodeWriter` no longer writes the
+   `ObjectCodeWriter:` and `Generated On:` header lines. Generated output holds nothing
+   that varies between runs or between a packaged writer and an owned copy of it.
 
 ## Status / known gaps
 
diff --git a/server/java/codegen-base/src/test/java/com/metaobjects/generator/direct/object/EjectedBaseGeneratorsCompileTest.java b/server/java/codegen-base/src/test/java/com/metaobjects/generator/direct/object/EjectedBaseGeneratorsCompileTest.java
new file mode 100644
index 000000000..cce3db6f2
--- /dev/null
+++ b/server/java/codegen-base/src/test/java/com/metaobjects/generator/direct/object/EjectedBaseGeneratorsCompileTest.java
@@ -0,0 +1,105 @@
+package com.metaobjects.generator.direct.object;
+
+import com.metaobjects.generator.util.JavaCompileTestSupport;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Eject proof (a) for the two generators this module ships a reference for: {@code entity}
+ * ({@code JavaObjectCodeGenerator}) and {@code extractor} ({@code ExtractorCodeGenerator}).
+ * Each one's copy set (the generator and the classes that hold the rest of its emit)
+ * compiles in ONE package of the adopter's, against this module's PUBLISHED API and nothing
+ * else, which is what a {@code codegen/} module has after {@code mvn metaobjects:eject}.
+ *
+ * <p>The sibling of {@code EjectedGeneratorsCompileTest} in {@code codegen-spring}, and it
+ * reads {@code src/main/java} for the same reason: the eject mojo lives downstream of this
+ * module, where {@code EntityExtractorEjectRoundTripTest} runs the real one. A copy set is
+ * closed when this compiles: a class in it that names a same-package class left out of the
+ * set, or calls a member of one that is not public, fails here with the "cannot find
+ * symbol" an adopter's build would show.</p>
+ */
+public class EjectedBaseGeneratorsCompileTest {
+
+    @Rule
+    public TemporaryFolder tempFolder = new TemporaryFolder();
+
+    private static final String REFERENCE_PACKAGE = "com.metaobjects.generator.direct.object";
+    private static final String OWNED_PACKAGE = "com.acme.owned";
+
+    /** What eject copies for {@code entity}, as class names under {@link #REFERENCE_PACKAGE}. */
+    private static final List<String> ENTITY = List.of(
+            "javacode.JavaObjectCodeGenerator",
+            "javacode.JavaCodeGenerator",
+            "BaseObjectCodeGenerator",
+            "BaseObjectCodeWriter",
+            "javacode.JavaCodeWriter",
+            "javacode.PojoAwareCodeWriter",
+            "javacode.ValueObjectCodeWriter");
+
+    /** What eject copies for {@code extractor}. */
+    private static final List<String> EXTRACTOR = List.of(
+            "javacode.ExtractorCodeGenerator",
+            "javacode.JavaCodeWriter",
+            "BaseObjectCodeWriter");
+
+    private static final Pattern PACKAGE_LINE = Pattern.compile("(?m)^package\\s+[\\w.]+\\s*;\\s*$");
+
+    private static String simpleName(String className) {
+        return className.substring(className.lastIndexOf('.') + 1);
+    }
+
+    /** The two edits eject makes: the package line, and imports of the classes copied along. */
+    private static String owned(String source, List<String> copySet) {
+        Matcher m = PACKAGE_LINE.matcher(source);
+        assertTrue("expected a package line", m.find());
+        String out = new StringBuilder(source)
+                .replace(m.start(), m.end(), "package " + OWNED_PACKAGE + ";").toString();
+        for (String className : copySet) {
+            out = out.replace("import " + REFERENCE_PACKAGE + "." + className + ";",
+                    "import " + OWNED_PACKAGE + "." + simpleName(className) + ";");
+        }
+        return out;
+    }
+
+    private void compilesInOnePackage(String label, List<String> copySet) throws IOException {
+        Path srcRoot = Path.of("src/main/java", REFERENCE_PACKAGE.replace('.', '/'));
+        Path ownedRoot = tempFolder.newFolder(label).toPath();
+        Path outDir = ownedRoot.resolve(OWNED_PACKAGE.replace('.', '/'));
+        Files.createDirectories(outDir);
+
+        for (String className : copySet) {
+            Path original = srcRoot.resolve(className.replace('.', '/') + ".java");
+            assertTrue("expected " + original + " to exist", Files.exists(original));
+            Files.writeString(outDir.resolve(simpleName(className) + ".java"),
+                    owned(Files.readString(original, StandardCharsets.UTF_8), copySet),
+                    StandardCharsets.UTF_8);
+        }
+
+        // In-process compile against this module's published API and the test classpath —
+        // exactly what an adopter's codegen/ module holds after eject. The shared
+        // codegen-base compile helper, which dumps the sources on failure.
+        JavaCompileTestSupport.compileGenerated(ownedRoot,
+                tempFolder.newFolder(label + "-classes").toPath());
+    }
+
+    @Test
+    public void entityCompilesWithItsWritersInOneOwnedPackage() throws IOException {
+        compilesInOnePackage("entity", ENTITY);
+    }
+
+    @Test
+    public void extractorCompilesWithItsNamingWriterInOneOwnedPackage() throws IOException {
+        compilesInOnePackage("extractor", EXTRACTOR);
+    }
+}
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
new file mode 100644
index 000000000..8a8ab7696
--- /dev/null
+++ b/server/java/codegen-base/src/test/java/com/metaobjects/generator/direct/object/StandaloneExtractorGeneratorTest.java
@@ -0,0 +1,223 @@
+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;
+import com.metaobjects.generator.direct.object.javacode.JavaObjectCodeGenerator;
+import com.metaobjects.loader.InMemoryStringSource;
+import com.metaobjects.loader.LoaderOptions;
+import com.metaobjects.loader.MetaDataLoader;
+import com.metaobjects.registry.ObjectClassRegistry;
+import org.junit.After;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * The {@code extractor} generator wired on its own.
+ *
+ * <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>
+ */
+public class StandaloneExtractorGeneratorTest {
+
+    private static final String PKG = "acme::shapes";
+
+    /** An abstract base, a concrete subtype, and an object nesting another. */
+    private static final String META = "{ \"metadata.root\": {"
+        + "  \"package\": \"" + PKG + "\","
+        + "  \"children\": ["
+        + "    { \"object.value\": { \"name\": \"Shape\", \"abstract\": true, \"children\": ["
+        + "      { \"field.string\": { \"name\": \"label\" } }"
+        + "    ]}},"
+        + "    { \"object.value\": { \"name\": \"Circle\", \"extends\": \"Shape\", \"children\": ["
+        + "      { \"field.double\": { \"name\": \"radius\" } }"
+        + "    ]}},"
+        + "    { \"object.value\": { \"name\": \"Drawing\", \"children\": ["
+        + "      { \"field.string\": { \"name\": \"title\" } },"
+        + "      { \"field.object\": { \"name\": \"outline\", \"@objectRef\": \"" + PKG + "::Circle\" } }"
+        + "    ]}}"
+        + "  ]"
+        + "}}";
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    @After
+    public void resetRegistry() {
+        ObjectClassRegistry.resetGlobal();
+    }
+
+    private MetaDataLoader loadMeta() {
+        MetaDataLoader loader = new MetaDataLoader(
+                LoaderOptions.create(false, false, true),
+                MetaDataLoader.SUBTYPE_MANUAL, "standalone-extractor");
+        loader.init();
+        loader.load(List.of(new InMemoryStringSource(META, "standalone-extractor/meta.json")));
+        return loader;
+    }
+
+    private static Map<String, String> entityArgs(Path out, String flavor) {
+        Map<String, String> args = new HashMap<>();
+        args.put("outputDir", out.toString());
+        args.put("type", "class");
+        args.put("flavor", flavor);
+        return args;
+    }
+
+    private static void run(Generator generator, Map<String, String> args, MetaDataLoader loader) {
+        generator.setArgs(args);
+        generator.execute(loader);
+    }
+
+    /** Every {@code *Extractor.java} under {@code root}, by path relative to it. */
+    private static Map<String, String> extractors(Path root) throws IOException {
+        Map<String, String> out = new TreeMap<>();
+        try (Stream<Path> walk = Files.walk(root)) {
+            for (Path p : (Iterable<Path>) walk.filter(Files::isRegularFile)::iterator) {
+                if (p.getFileName().toString().endsWith("Extractor.java")) {
+                    out.put(root.relativize(p).toString().replace('\\', '/'),
+                            Files.readString(p, StandardCharsets.UTF_8));
+                }
+            }
+        }
+        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()));
+    }
+
+    @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")));
+    }
+
+    @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();
+        Map<String, String> args = new HashMap<>();
+        args.put("outputDir", standalone.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)) {
+            assertEquals(2, walk.filter(Files::isRegularFile).count());
+        }
+    }
+
+    @Test
+    public void itNamesTheExtractorsByTheSameArgsEntityNamesItsClassesBy() throws Exception {
+        Map<String, String> naming = new HashMap<>();
+        naming.put("pkgPrefix", "com.example");
+        naming.put("pkgSuffix", "model");
+        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());
+
+        assertTrue(extractors(standalone).containsKey(
+                "com/example/acme/shapes/model/MyCircleVoExtractor.java"));
+        assertEquals(extractors(fused), extractors(standalone));
+    }
+
+    @Test
+    public void givenEntitysFiltersItWritesAnExtractorForExactlyTheClassesEntityWrites() throws Exception {
+        List<String> filters = 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));
+    }
+
+    @Test
+    public void itRefusesToRunWithNoOutputDirectory() {
+        try {
+            run(new ExtractorCodeGenerator(), new HashMap<>(), loadMeta());
+            fail("expected a GeneratorException naming the missing outputDir");
+        } catch (GeneratorException e) {
+            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-spring/pom.xml b/server/java/codegen-spring/pom.xml
index 0da498c86..a350c68fa 100644
--- a/server/java/codegen-spring/pom.xml
+++ b/server/java/codegen-spring/pom.xml
@@ -160,10 +160,10 @@
                  resource IS the source, one file, one owner. See
                  com.metaobjects.generator.GeneratorRegistry.EJECT_RESOURCE_ROOT.
 
-                 Deliberately excludes "extractor" (ExtractorCodeGenerator — fused into
-                 "entity", not separately wirable) and "template" (TemplateScopeGenerator —
-                 a generic declarative primitive with no emit logic to own); see
-                 GeneratorRegistry's javadoc on those two entries. -->
+                 "entity" and "extractor" are not in this list because codegen-base owns
+                 them: its pom ships their source the same way. "template"
+                 (TemplateScopeGenerator) ships nowhere: it is a generic declarative
+                 primitive with no emit logic to own; see GeneratorRegistry. -->
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-resources-plugin</artifactId>
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 deaa58c26..9957a1277 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,7 +1,13 @@
 package com.metaobjects.generator;
 
+import com.metaobjects.generator.direct.object.BaseObjectCodeGenerator;
+import com.metaobjects.generator.direct.object.BaseObjectCodeWriter;
 import com.metaobjects.generator.direct.object.javacode.ExtractorCodeGenerator;
+import com.metaobjects.generator.direct.object.javacode.JavaCodeGenerator;
+import com.metaobjects.generator.direct.object.javacode.JavaCodeWriter;
 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.JUnitRequirementTestsGenerator;
 import com.metaobjects.generator.spring.LlmTraceHelperGenerator;
 import com.metaobjects.generator.spring.SpringControllerGenerator;
@@ -93,6 +99,8 @@ public static final class GeneratorInfo {
         private final Layer layer;
         private final String ejectResourcePath;
         private final List<String> ejectRuntime;
+        private final String ejectNote;
+        private final List<String> ejectWith;
 
         public GeneratorInfo(String stableName, String classname, String description,
                              Tier tier, Layer layer) {
@@ -109,11 +117,9 @@ public GeneratorInfo(String stableName, String classname, String description,
          *      as shipped inside the {@code codegen-*} jar that owns it (e.g. {@code
          *      META-INF/metaobjects/reference/java/SpringNamesGenerator.java}), or {@code
          *      null} when this generator is not ejectable — {@code mvn metaobjects:eject}
-         *      reads this field to resolve {@code -Dnames}. See {@link
-         *      docs/superpowers/specs/2026-09-22-eject-in-every-port-design.md the JVM
-         *      eject design} for why some registered generators (the "extractor" that is
-         *      fused into "entity"; "template", a generic declarative primitive with no
-         *      emit logic to own) deliberately carry no eject source.
+         *      reads this field to resolve {@code -Dnames}. One registered generator carries
+         *      none: "template", the Mustache primitive, which has no emit logic to own
+         *      (ADR-0034 Amendment 6).
          * @param ejectRuntime simple names of the helper-runtime classes this generator's
          *      OUTPUT imports (from {@link #RUNTIME_PACKAGE}), closed over their own references
          *      to each other. {@code mvn metaobjects:eject} copies their source (shipped under
@@ -123,6 +129,25 @@ 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) {
+            this(stableName, classname, description, tier, layer, ejectResourcePath,
+                    ejectRuntime, null, List.of());
+        }
+
+        /**
+         * @param ejectNote wiring the generic eject report cannot know, printed after it;
+         *      {@code null} for a generator whose only wiring is the {@code <classname>}
+         *      change. {@code {owned}} in it is replaced by the owned copy's class name.
+         * @param ejectWith fully-qualified names of the classes that hold the rest of this
+         *      GENERATOR's emit (its bases and writers), closed over their references to each
+         *      other. {@code mvn metaobjects:eject} copies each one's source (shipped at
+         *      {@link #EJECT_RESOURCE_ROOT}{@code <SimpleName>.java}) into the same owned
+         *      package as the generator and points their imports of one another at the copies,
+         *      so an owned generator extends and calls owned code. Not {@code ejectRuntime}:
+         *      that is what the generated OUTPUT imports.
+         */
+        public GeneratorInfo(String stableName, String classname, String description,
+                             Tier tier, Layer layer, String ejectResourcePath,
+                             List<String> ejectRuntime, String ejectNote, List<String> ejectWith) {
             this.stableName = stableName;
             this.classname = classname;
             this.description = description;
@@ -130,6 +155,8 @@ public GeneratorInfo(String stableName, String classname, String description,
             this.layer = layer;
             this.ejectResourcePath = ejectResourcePath;
             this.ejectRuntime = List.copyOf(ejectRuntime);
+            this.ejectNote = ejectNote;
+            this.ejectWith = List.copyOf(ejectWith);
         }
 
         /** Canonical cross-port stable name (the manifest key). */
@@ -169,6 +196,18 @@ public List<String> ejectRuntime() {
             return ejectRuntime;
         }
 
+        /** Wiring to print after the generic eject report, or {@code null} (see the
+         *  constructor). */
+        public String ejectNote() {
+            return ejectNote;
+        }
+
+        /** Fully-qualified names of the classes copied with this generator into its owned
+         *  package, the rest of its emit (see the constructor). */
+        public List<String> ejectWith() {
+            return ejectWith;
+        }
+
         @Override
         public String toString() {
             return "GeneratorInfo{" + stableName + " -> " + classname
@@ -183,6 +222,17 @@ public String toString() {
             "ConstraintErrors", "FilterParseResult", "FilterParser", "FilterPredicate",
             "PatchValidationException", "RecordComponentNames");
 
+    /** The writer a generated type's package and class name are read from, and its base. */
+    private static final List<String> OBJECT_NAMING = List.of(
+            JavaCodeWriter.class.getName(), BaseObjectCodeWriter.class.getName());
+
+    /** The rest of "entity"'s emit: the bases that parse its arguments and place each file,
+     *  and the writers that emit the class body, one per flavor. */
+    private static final List<String> ENTITY_EMIT = List.of(
+            JavaCodeGenerator.class.getName(), BaseObjectCodeGenerator.class.getName(),
+            BaseObjectCodeWriter.class.getName(), JavaCodeWriter.class.getName(),
+            PojoAwareCodeWriter.class.getName(), ValueObjectCodeWriter.class.getName());
+
     private static final Map<String, GeneratorInfo> REGISTRY = buildRegistry();
 
     /** Classpath root every ejectable Java generator's reference source is shipped under
@@ -209,17 +259,13 @@ private static String ejectPath(Class<?> impl) {
 
     private static Map<String, GeneratorInfo> buildRegistry() {
         Map<String, GeneratorInfo> m = new LinkedHashMap<>();
-        // "entity" stays registered but is NOT ejectable on Java: JavaObjectCodeGenerator
-        // lives in codegen-base (not this module), extends a same-package superclass
-        // (JavaCodeGenerator), and directly instantiates the FUSED, non-ejectable
-        // ExtractorCodeGenerator plus other same-package writer helpers
-        // (PojoAwareCodeWriter / ValueObjectCodeWriter). Ejecting it would mean widening a
-        // whole internal writer hierarchy to public — a materially bigger surface than the
-        // other ten generators, for a generator this port already documents as fused to a
-        // non-ejectable neighbor. Kotlin's "entity" (KotlinEntityGenerator) has no such
-        // entanglement and IS ejectable — see GeneratorRegistry.kt.
+        // "entity" and "extractor" live in codegen-base, which ships their reference source
+        // (its pom, the same execution as this module's). The class body "entity" writes is
+        // emitted by its writers, so the owned copy is the generator AND those writers, with
+        // the two bases between it and the file loop (ADR-0034 Amendment 6).
         register(m, "entity", JavaObjectCodeGenerator.class.getName(),
-                "Per-entity Java model/class (table-backed or value object).", Tier.NATIVE, Layer.MODEL);
+                "Per-entity Java model/class (table-backed or value object).", Tier.NATIVE, Layer.MODEL,
+                ejectPath(JavaObjectCodeGenerator.class), List.of(), null, ENTITY_EMIT);
         register(m, "routes", SpringControllerGenerator.class.getName(),
                 "Per-entity Spring @RestController endpoint surface.", Tier.NATIVE, Layer.API,
                 ejectPath(SpringControllerGenerator.class), ROUTES_RUNTIME);
@@ -236,13 +282,26 @@ private static Map<String, GeneratorInfo> buildRegistry() {
         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" stays registered (discoverable, cross-port symmetric) but is NOT
-        // ejectable: it is fused into "entity"'s own emission (JavaObjectCodeGenerator),
-        // not a separately wirable generator with its own emit logic to own.
+        // "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.
         register(m, "extractor", ExtractorCodeGenerator.class.getName(),
-                "Per-template typed extract<Name> helper: tolerant recovery of the typed response from "
-                    + "dirty model text; throws only when a @required field is lost. FUSED into `entity` on this "
-                    + "port — emitted by JavaObjectCodeGenerator, not separately wirable.", Tier.NATIVE, Layer.CAPABILITY);
+                "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,
+                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 "
+                    + "<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.",
+                OBJECT_NAMING);
         // "template" stays registered but is NOT ejectable: it is already a generic,
         // declaratively-configured primitive (Mustache template + output pattern) with no
         // emit LOGIC in it to own — you customize it via args/template-spec, not by editing
@@ -294,8 +353,16 @@ private static void register(Map<String, GeneratorInfo> m, String stableName,
     private static void register(Map<String, GeneratorInfo> m, String stableName,
                                  String classname, String description, Tier tier, Layer layer,
                                  String ejectResourcePath, List<String> ejectRuntime) {
+        register(m, stableName, classname, description, tier, layer, ejectResourcePath,
+                ejectRuntime, null, 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) {
         if (m.put(stableName, new GeneratorInfo(stableName, classname, description, tier, layer,
-                ejectResourcePath, ejectRuntime)) != null) {
+                ejectResourcePath, ejectRuntime, ejectNote, ejectWith)) != null) {
             throw new IllegalStateException("duplicate generator stable name: " + stableName);
         }
     }
diff --git a/server/java/codegen-spring/src/test/java/com/metaobjects/generator/GeneratorRegistryConformanceTest.java b/server/java/codegen-spring/src/test/java/com/metaobjects/generator/GeneratorRegistryConformanceTest.java
index 4e2f3abba..5e66fba6f 100644
--- a/server/java/codegen-spring/src/test/java/com/metaobjects/generator/GeneratorRegistryConformanceTest.java
+++ b/server/java/codegen-spring/src/test/java/com/metaobjects/generator/GeneratorRegistryConformanceTest.java
@@ -47,17 +47,16 @@ public class GeneratorRegistryConformanceTest {
      * {@link #everyRegisteredClassnameLoadsAndIsAWirableGenerator()} asserts the set matches
      * EXACTLY, so a NEW one fails just as loudly as one that has quietly been fixed.
      *
-     * <p>{@code extractor} → {@code ExtractorCodeGenerator} is an emission HELPER driven by
-     * {@code JavaObjectCodeGenerator.execute}: its output SHIPS whenever {@code entity} runs
-     * — every non-abstract object gets an extractor — it is simply not independently wirable
-     * in a {@code <generator>} entry the way the other four ports expose it. A fusion, not a
-     * gap; {@code docs/ports/java.md} says so where an adopter will look.</p>
+     * <p>Empty. {@code extractor} was the one member while {@code ExtractorCodeGenerator} was
+     * only a step inside {@code entity}; it is a generator of its own now, as on the other
+     * four ports, and {@code entity} still writes its files when no separate one is in the
+     * run.</p>
      *
      * <p>Shared with {@code NoMagicPhysicalNamesTest}, which must skip exactly these rows
      * when it builds a suite off the registry. ONE definition, so the two cannot drift into
      * disagreeing about which rows are runnable.</p>
      */
-    public static final Set<String> FUSED_NOT_WIRABLE = Set.of("extractor");
+    public static final Set<String> NOT_WIRABLE = Set.of();
 
     /** Walk up from the test's working dir to the repo root (the dir holding both {@code fixtures/} and {@code server/}). */
     private static Path repoRoot() {
@@ -261,8 +260,8 @@ public void everyRegisteredClassnameLoadsAndIsAWirableGenerator() {
 
         assertEquals("every registered classname must resolve on this port's classpath",
                 new TreeSet<String>(), unloadable);
-        assertEquals("registry rows that a <generator> entry cannot wire — see FUSED_NOT_WIRABLE",
-                new TreeSet<>(FUSED_NOT_WIRABLE), notWirable);
+        assertEquals("registry rows that a <generator> entry cannot wire — see NOT_WIRABLE",
+                new TreeSet<>(NOT_WIRABLE), notWirable);
     }
 
     /**
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 2ec311da3..c5f693f39 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,5 +1,7 @@
 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;
 import com.metaobjects.generator.util.GeneratedFileWriter;
@@ -143,6 +145,7 @@ private void generateAndCompile(String label, Map<String, Map<String, String>> s
     private static Generator newGenerator(String stableName) {
         switch (stableName) {
             case "entity":           return new JavaObjectCodeGenerator();
+            case "extractor":        return new ExtractorCodeGenerator();
             case "value-object":     return new SpringValueObjectGenerator();
             case "dto":              return new SpringDtoGenerator();
             case "repository":       return new SpringRepositoryGenerator();
@@ -180,6 +183,23 @@ public void theJavaModelTierCompiles() throws Exception {
         generateAndCompile("model", selection, 17);
     }
 
+    /**
+     * 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.
+     */
+    @Test
+    public void theJavaModelTierCompilesWithTheExtractorsFromTheirOwnGenerator() throws Exception {
+        Map<String, String> entityOnly = new LinkedHashMap<>(AS_CLASS);
+        entityOnly.put(EmitsObjectExtractors.ARG_EMIT_EXTRACTORS, "false");
+        Map<String, Map<String, String>> selection = new LinkedHashMap<>();
+        selection.put("entity", entityOnly);
+        selection.put("extractor", PLAIN);
+        selection.put("names", PLAIN);
+        generateAndCompile("model-split", selection, 17, "ProgramExtractor");
+    }
+
     /**
      * The Spring request/response tier: the DTO/Patch pair, the value-object records they
      * bind, the repositories and the filter allowlists, including the read-only surface of
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 01d64937b..7a6f1fcbe 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,5 +1,6 @@
 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;
@@ -452,15 +453,17 @@ private Map<String, String> generate() throws Exception {
         }
         // A registry entry that cannot be built as a Generator is skipped — but the SET of
         // them is PINNED, because silently dropping entries is how a generator escapes this
-        // gate. The pin is GeneratorRegistryConformanceTest.FUSED_NOT_WIRABLE, which owns
+        // gate. The pin is GeneratorRegistryConformanceTest.NOT_WIRABLE, which owns
         // the question and states the reason; asserting it here too means this suite cannot
         // quietly start covering less than that ruling says it does.
         assertEquals("registry entries that are not Generators",
-            new TreeSet<>(GeneratorRegistryConformanceTest.FUSED_NOT_WIRABLE), notGenerators);
+            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.
-        Map<String, String> runArgs = EmitsPhysicalNameConstants.deriveUseNames(args, suite);
+        // 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);
         for (Generator g : suite) {
             g.setArgs(new HashMap<>(runArgs));
             g.execute(loader);
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 da873f6d7..840ef8209 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
@@ -72,8 +72,6 @@ public class ReportingInertTest extends SharedRegistryTestBase {
         "repository", "acme/shop/StoreTotalsRepository.java",
         "filter-allowlist", "acme/shop/StoreTotalsFilterAllowlist.java",
         "routes", "acme/shop/StoreTotalsController.java");
-    private static final java.util.regex.Pattern GENERATED_ON =
-        java.util.regex.Pattern.compile("Generated On:[^\\n]*");
 
     private static Path model(String variant) {
         return SpringTestFixtures.findCorpusRoot().getParent()
@@ -121,10 +119,7 @@ private Map<String, String> emit(String variant, List<GeneratorInfo> suite) thro
         }
         try (Stream<Path> s = Files.walk(outDir)) {
             for (Path p : s.filter(Files::isRegularFile).collect(Collectors.toList())) {
-                // The model tier stamps a wall-clock "Generated On:" line into every class
-                // header; two runs a second apart differ there and nowhere else by design.
-                files.put(outDir.relativize(p).toString(),
-                    GENERATED_ON.matcher(Files.readString(p, StandardCharsets.UTF_8)).replaceAll("Generated On: <time>"));
+                files.put(outDir.relativize(p).toString(), Files.readString(p, StandardCharsets.UTF_8));
             }
         }
         return files;
@@ -204,7 +199,6 @@ public void exactlyTheseGeneratorsCannotRunFromABareModel() throws Exception {
         // 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.
-        //   extractor  not a Generator at all: fused into `entity`, which emits it
         //   template   needs a `template` arg (no default template exists)
         List<String> threw = new ArrayList<>();
         StringBuilder why = new StringBuilder();
@@ -216,7 +210,7 @@ public void exactlyTheseGeneratorsCannotRunFromABareModel() throws Exception {
             }
         }
         threw.sort(null);
-        assertEquals(why.toString(), List.of("extractor", "template"), threw);
+        assertEquals(why.toString(), List.of("template"), threw);
     }
 
     @Test
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 9d5ea6da2..96a6f3339 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,6 +14,7 @@
 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;
@@ -199,9 +200,16 @@ 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(
-                EmitsPhysicalNameConstants.deriveUseNames( argsByGenerator.get(i), generatorImpls ) );
+                EmitsObjectExtractors.deriveEmitExtractors( derived, generatorImpls ) );
         }
 
         return generatorImpls;
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 025845f7e..071879a80 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
@@ -62,6 +62,12 @@ public static final class Entry {
          *  eject copies alongside it (empty for every Kotlin generator — see
          *  {@link #allEntries()}). */
         public final List<String> runtime;
+        /** Wiring the generic eject report cannot know, with {@code {owned}} standing for the
+         *  owned copy's class name, or {@code null} (see {@link #wiringNote}). */
+        public final String note;
+        /** 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;
 
         public Entry(Port port, String stableName, String classname, String description, String resourcePath) {
             this(port, stableName, classname, description, resourcePath, List.of());
@@ -69,25 +75,59 @@ 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) {
+            this(port, stableName, classname, description, resourcePath, runtime, null, List.of());
+        }
+
+        public Entry(Port port, String stableName, String classname, String description,
+                     String resourcePath, List<String> runtime, String note, List<String> with) {
             this.port = port;
             this.stableName = stableName;
             this.classname = classname;
             this.description = description;
             this.resourcePath = resourcePath;
             this.runtime = List.copyOf(runtime);
+            this.note = note;
+            this.with = List.copyOf(with);
+        }
+
+        /** Every class eject copies for this generator, by fully-qualified name: the
+         *  generator first, then {@link #with}. */
+        public List<String> sources() {
+            List<String> out = new ArrayList<>();
+            out.add(classname);
+            out.addAll(with);
+            return out;
+        }
+
+        /** 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";
+        }
+
+        /** {@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());
         }
 
         /** The simple class name — also the filename stem the ejected copy is written as. */
         public String simpleName() {
-            int dot = classname.lastIndexOf('.');
-            return dot < 0 ? classname : classname.substring(dot + 1);
+            return simpleNameOf(classname);
         }
     }
 
+    /** The simple name of a fully-qualified class name. */
+    public static String simpleNameOf(String classname) {
+        int dot = classname.lastIndexOf('.');
+        return dot < 0 ? classname : classname.substring(dot + 1);
+    }
+
     /**
      * Every generator BOTH registries declare, ejectable or not (an entry with a {@code
      * null} {@link Entry#resourcePath} is registered but not ejectable — see {@code
-     * GeneratorRegistry}'s "extractor"/"template" javadoc). Insertion order: Java first,
+     * GeneratorRegistry}'s "template" entry). Insertion order: Java first,
      * then Kotlin, each in its own registry's declared order.
      *
      * <p>Only Java entries carry helper runtime. The Kotlin generators emit their filter
@@ -100,7 +140,8 @@ public static List<Entry> allEntries() {
         List<Entry> out = new ArrayList<>();
         for (GeneratorRegistry.GeneratorInfo info : GeneratorRegistry.list().values()) {
             out.add(new Entry(Port.JAVA, info.stableName(), info.classname(), info.description(),
-                    info.ejectResourcePath(), info.ejectRuntime()));
+                    info.ejectResourcePath(), info.ejectRuntime(), info.ejectNote(),
+                    info.ejectWith()));
         }
         for (Map.Entry<String, GeneratorInfo> e : GeneratorRegistryKt.getGENERATOR_REGISTRY().entrySet()) {
             GeneratorInfo info = e.getValue();
@@ -198,8 +239,9 @@ public static Port inferPort(List<String> declaredArtifactIds) {
     }
 
     // ------------------------------------------------------------------------------------
-    // package rewrite — the ONE edit a copy gets (ADR-0034; the JVM eject design's "the
-    // package rename is the only edit").
+    // package rewrite — the edit every copy gets (ADR-0034; the JVM eject design's "the
+    // package rename is the only edit"). A generator copied WITH other classes gets one
+    // more, which is the same rename seen from the importing side: see rewriteCopiedImports.
     // ------------------------------------------------------------------------------------
 
     private static final Pattern PACKAGE_LINE = Pattern.compile("(?m)^package\\s+[\\w.]+\\s*;?\\s*$");
@@ -220,6 +262,32 @@ public static String rewritePackage(String source, String newPackage) {
         return new StringBuilder(source).replace(m.start(), m.end(), replacement).toString();
     }
 
+    /**
+     * Point every import of a class in {@code copied} (fully-qualified names) at its copy in
+     * {@code ownedPackage}. The classes eject copies for one generator land in one package,
+     * 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.
+     */
+    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) + ";"));
+        }
+        return out;
+    }
+
+    /**
+     * The owned copy of {@code reference}, the source of one of {@code entry}'s
+     * {@link Entry#sources()}: its package renamed to {@code ownedPackage}, and its imports
+     * of the classes copied with it pointed at those copies.
+     */
+    public static String ownedSource(Entry entry, String reference, String ownedPackage) {
+        return rewriteCopiedImports(rewritePackage(reference, ownedPackage), entry.sources(), ownedPackage);
+    }
+
     // ------------------------------------------------------------------------------------
     // helper runtime — the source a generator's OUTPUT imports, handed over with it
     // ------------------------------------------------------------------------------------
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 58860dc62..d648c1ed8 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
@@ -40,6 +40,12 @@
  * codegen/src/main/(java|kotlin)/<package path>/}. On first use it also writes {@code
  * codegen/pom.xml}.
  *
+ * <p><b>The rest of a generator's emit comes with it.</b> The Java {@code entity} generator
+ * emits each class body through writer classes, and {@code extractor} reads its names from
+ * one. Those classes ({@link EjectSupport.Entry#with}) are copied into the same package as
+ * the generator, and the imports the copies have of one another are pointed at the copies
+ * ({@link EjectSupport#ownedSource}), so the owned generator extends and calls owned code.
+ *
  * <p><b>The helper runtime comes too.</b> The Java controller, DTO and repository output
  * imports helper classes ({@code FilterParser}, {@code PatchValidationException},
  * {@code ConstraintErrors}, …) that are not core (ADR-0034 Amendment 3). Ejecting such a
@@ -160,28 +166,40 @@ public void execute() throws MojoExecutionException, MojoFailureException {
         // with no single obvious app module fails the whole call, not half of it.
         Path runtimeRoot = runtime.isEmpty() ? null : resolveRuntimeRoot();
 
+        // Two generators named in one call may share a class copied with each of them; it
+        // is written once.
+        Set<Path> copied = new LinkedHashSet<>();
         for (EjectSupport.Resolution r : resolved) {
             EjectSupport.Entry e = r.entry;
             portsTouched.add(e.port);
 
-            String reference;
-            try {
-                reference = readResource(e.resourcePath);
-            } catch (IOException ex) {
-                throw new MojoExecutionException(
-                        "Could not read reference source for \"" + e.stableName + "\" at classpath "
-                            + "resource " + e.resourcePath, ex);
-            }
-            String rewritten = EjectSupport.rewritePackage(reference, pkg);
-            if (!e.runtime.isEmpty()) {
-                rewritten = EjectSupport.rewriteRuntimePackage(rewritten, runtimePkg);
-            }
-
             String langDir = e.port == EjectSupport.Port.KOTLIN ? "kotlin" : "java";
             Path pkgDir = codegenRoot.resolve("src/main/" + langDir).resolve(pkg.replace('.', '/'));
-            Path target = pkgDir.resolve(e.simpleName() + "." + e.port.extension);
 
-            reportEject(e, target, rewritten, write(pkgDir, target, rewritten, force));
+            for (String source : e.sources()) {
+                String simpleName = EjectSupport.simpleNameOf(source);
+                Path target = pkgDir.resolve(simpleName + "." + e.port.extension);
+                if (!copied.add(target)) continue;
+
+                boolean generator = source.equals(e.classname);
+                String resource = e.resourceOf(source);
+                String reference;
+                try {
+                    reference = readResource(resource);
+                } catch (IOException ex) {
+                    throw new MojoExecutionException(
+                            "Could not read reference source for \"" + e.stableName + "\" at classpath "
+                                + "resource " + resource, ex);
+                }
+                String rewritten = EjectSupport.ownedSource(e, reference, pkg);
+                if (generator && !e.runtime.isEmpty()) {
+                    rewritten = EjectSupport.rewriteRuntimePackage(rewritten, runtimePkg);
+                }
+
+                String what = generator ? "\"" + e.stableName + "\""
+                        : simpleName + " (with \"" + e.stableName + "\")";
+                reportEject(what, target, rewritten, write(pkgDir, target, rewritten, force));
+            }
             classnameChanges.add("  " + e.stableName + ": " + e.classname + "  ->  "
                     + pkg + "." + e.simpleName());
         }
@@ -193,6 +211,11 @@ public void execute() throws MojoExecutionException, MojoFailureException {
         }
 
         printWiring(pomWritten, classnameChanges);
+        // Wiring a generator's entry adds to the generic report, in the order requested.
+        for (EjectSupport.Resolution r : resolved) {
+            String note = r.entry.wiringNote(pkg);
+            if (note != null) getLog().info(note);
+        }
         if (!runtime.isEmpty()) {
             printRuntimeWiring(runtimeRoot, runtimePkg, requested, codegenRoot);
         }
@@ -328,15 +351,15 @@ private WriteStatus write(Path dir, Path target, String content, boolean force)
         }
     }
 
-    private void reportEject(EjectSupport.Entry e, Path target, String rewritten, WriteStatus status)
+    private void reportEject(String what, Path target, String rewritten, WriteStatus status)
             throws MojoExecutionException {
         switch (status) {
             case CREATED:
-                getLog().info("Ejected \"" + e.stableName + "\" -> " + target
+                getLog().info("Ejected " + what + " -> " + target
                         + ". You own it now (ADR-0034 scaffold-and-own).");
                 break;
             case REPLACED:
-                getLog().info("Ejected \"" + e.stableName + "\" -> " + target + ", REPLACING the file "
+                getLog().info("Ejected " + what + " -> " + target + ", REPLACING the file "
                         + "that was there (-Dforce=true).");
                 break;
             case PRESERVED:
@@ -567,12 +590,26 @@ private String ownedStaleness(Path codegenRoot, EjectSupport.Entry e) {
             Path found = walk.filter(p -> p.getFileName().toString().equals(filename))
                     .findFirst().orElse(null);
             if (found == null) return null;
-            String owned = Files.readString(found, StandardCharsets.UTF_8);
-            String reference = readResource(e.resourcePath);
-            EjectSupport.Comparison cmp = EjectSupport.compare(owned, reference);
-            return cmp.verdict == EjectSupport.Verdict.IDENTICAL
+            // The generator is owned together with every class copied with it, so the verdict
+            // is over all of them, each against what eject would write beside this copy. One
+            // that has gone missing counts as wholly behind.
+            String ownedPackage = srcRoot.relativize(found.getParent()).toString()
+                    .replace(found.getFileSystem().getSeparator(), ".");
+            int behind = 0;
+            int ownedOnly = 0;
+            for (String source : e.sources()) {
+                Path file = found.resolveSibling(
+                        EjectSupport.simpleNameOf(source) + "." + e.port.extension);
+                String owned = Files.exists(file) ? Files.readString(file, StandardCharsets.UTF_8) : "";
+                String reference = EjectSupport.rewriteCopiedImports(
+                        readResource(e.resourceOf(source)), e.sources(), ownedPackage);
+                EjectSupport.Comparison cmp = EjectSupport.compare(owned, reference);
+                behind += cmp.behind;
+                ownedOnly += cmp.ownedOnly;
+            }
+            return behind == 0 && ownedOnly == 0
                     ? "[owned — identical]"
-                    : "[owned — DIFFERS: " + cmp.behind + " behind, " + cmp.ownedOnly + " of your own]";
+                    : "[owned — DIFFERS: " + behind + " behind, " + ownedOnly + " of your own]";
         } catch (IOException ex) {
             return "[owned — could not compare: " + ex.getMessage() + "]";
         }
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 a5cf5b230..0a5123ce6 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
@@ -107,6 +107,9 @@ private Map<String, String> args(Path outDir) {
         a.put("outputDir", outDir.toString());
         a.put("packageName", "fitness");
         a.put("templateRoot", canonical.resolve("prompts").toString());
+        // Required by the entity generator (JavaObjectCodeGenerator), ignored by the rest.
+        a.put("type", "class");
+        a.put("flavor", "pojoAware");
         return a;
     }
 
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 fe0c23754..ddcc46b11 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
@@ -34,46 +34,51 @@ public void everyEntryHasAPortAndAStableName() {
     }
 
     @Test
-    public void javasFusedExtractorGenericTemplateAndEntangledEntityAreRegisteredButNotEjectable() {
-        List<EjectSupport.Entry> all = EjectSupport.allEntries();
-        boolean sawJavaExtractor = false, sawJavaTemplate = false, sawJavaEntity = false;
-        for (EjectSupport.Entry e : all) {
-            if (e.port == EjectSupport.Port.JAVA && e.stableName.equals("extractor")) {
-                sawJavaExtractor = true;
-                assertNull("extractor is fused into entity — not ejectable on Java", e.resourcePath);
-            }
-            if (e.port == EjectSupport.Port.JAVA && e.stableName.equals("template")) {
-                sawJavaTemplate = true;
-                assertNull("template is a generic declarative primitive — not ejectable", e.resourcePath);
-            }
-            if (e.port == EjectSupport.Port.JAVA && e.stableName.equals("entity")) {
-                sawJavaEntity = true;
-                assertNull("entity lives in codegen-base and is entangled with the fused "
-                        + "extractor plus a same-package writer hierarchy — not ejectable on Java",
-                        e.resourcePath);
-            }
+    public void onJavaOnlyTheGenericTemplateIsRegisteredButNotEjectable() {
+        java.util.Set<String> notEjectable = new java.util.TreeSet<>();
+        for (EjectSupport.Entry e : EjectSupport.allEntries()) {
+            if (e.port == EjectSupport.Port.JAVA && e.resourcePath == null) notEjectable.add(e.stableName);
         }
-        assertTrue(sawJavaExtractor);
-        assertTrue(sawJavaTemplate);
-        assertTrue(sawJavaEntity);
+        // PINNED: template is the Mustache primitive, with no emit logic to own. entity and
+        // extractor were the other two until ADR-0034 Amendment 6; a generator that joins
+        // this set has to be ruled on, not slipped in.
+        assertEquals(java.util.Set.of("template"), notEjectable);
     }
 
     @Test
-    public void kotlinsEntityIsEjectableAndUnambiguousSinceJavasIsNot() {
+    public void entityAndExtractorAreEjectableOnBothPortsAndSoNeedAPort() {
         Map<String, List<EjectSupport.Entry>> catalog = EjectSupport.ejectableByStableName();
-        assertEquals(1, catalog.get("entity").size());
-        EjectSupport.Resolution r = EjectSupport.resolve("entity", catalog, null, null);
-        assertTrue(r.ok());
-        assertEquals(EjectSupport.Port.KOTLIN, r.entry.port);
+        for (String name : List.of("entity", "extractor")) {
+            assertEquals(name, 2, catalog.get(name).size());
+            EjectSupport.Resolution noHint = EjectSupport.resolve(name, catalog, null, null);
+            assertFalse(name, noHint.ok());
+            assertTrue(noHint.error, noHint.error.contains("-Dport"));
+
+            EjectSupport.Resolution java = EjectSupport.resolve(name, catalog, EjectSupport.Port.JAVA, null);
+            assertTrue(name, java.ok());
+            assertEquals(EjectSupport.Port.JAVA, java.entry.port);
+            assertTrue(java.entry.classname,
+                    java.entry.classname.startsWith("com.metaobjects.generator.direct.object.javacode."));
+
+            EjectSupport.Resolution kotlin = EjectSupport.resolve(name, catalog, EjectSupport.Port.KOTLIN, null);
+            assertTrue(name, kotlin.ok());
+            assertEquals(EjectSupport.Port.KOTLIN, kotlin.entry.port);
+        }
     }
 
     @Test
-    public void kotlinsExtractorIsEjectable() {
-        List<EjectSupport.Entry> all = EjectSupport.allEntries();
-        boolean found = all.stream().anyMatch(e ->
-                e.port == EjectSupport.Port.KOTLIN && e.stableName.equals("extractor")
-                        && e.resourcePath != null);
-        assertTrue("Kotlin's extractor is a standalone generator, unlike Java's fused one", found);
+    public void onlyTheJavaExtractorCarriesAWiringNoteAndItNamesTheOwnedClass() {
+        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"));
+                continue;
+            }
+            String note = e.wiringNote("com.acme.codegen");
+            assertTrue(note, note.contains(
+                    "<classname>com.acme.codegen.ExtractorCodeGenerator</classname>"));
+            assertFalse(note, note.contains("{owned}"));
+        }
     }
 
     @Test
@@ -167,6 +172,34 @@ public void rewritePackageRejectsSourceWithNoPackageLine() {
         EjectSupport.rewritePackage("class Foo {}", "com.acme.codegen");
     }
 
+    /**
+     * 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.
+     */
+    @Test
+    public void anImportOfAClassCopiedAlongFollowsTheCopyAndNoOtherImportMoves() {
+        EjectSupport.Entry entity = EjectSupport.resolve(
+                "entity", EjectSupport.ejectableByStableName(), EjectSupport.Port.JAVA, null).entry;
+        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.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.direct.GenerationContext;\n\n"
+                + "public class Foo extends BaseObjectCodeWriter {}\n",
+                EjectSupport.rewriteCopiedImports(src, entity.sources(), "com.acme.codegen"));
+        assertTrue(EjectSupport.ownedSource(entity, src, "com.acme.codegen")
+                .startsWith("package com.acme.codegen;\n"));
+    }
+
     // ------------------------------------------------------------------------------------
     // owned-copy comparison
     // ------------------------------------------------------------------------------------
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
new file mode 100644
index 000000000..da81488c8
--- /dev/null
+++ b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EmitExtractorsDerivationTest.java
@@ -0,0 +1,103 @@
+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
new file mode 100644
index 000000000..69b2e0f53
--- /dev/null
+++ b/server/java/maven-plugin/src/test/java/com/metaobjects/mojo/EntityExtractorEjectRoundTripTest.java
@@ -0,0 +1,514 @@
+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;
+import com.metaobjects.loader.LoaderOptions;
+import com.metaobjects.loader.MetaDataLoader;
+import com.metaobjects.loader.uri.URIHelper;
+import org.apache.maven.plugin.MojoFailureException;
+import org.apache.maven.plugin.logging.Log;
+import org.apache.maven.project.MavenProject;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+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.net.URI;
+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.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+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;
+import static org.junit.Assert.fail;
+
+/**
+ * The Java {@code entity} and {@code extractor} generators are ejectable, proven five ways
+ * (ADR-0034 Amendment 6): {@code mvn metaobjects:eject} copies each one with the rest of its
+ * emit, the writers included; the copies, unchanged and compiled against the published jars,
+ * write the same bytes as the packaged generator over the shared persistence corpus; an edit
+ * to an owned writer changes the class body the owned generator writes; {@code -Dlist}
+ * reports them and their owned copies like any other generator; and
+ * {@code mvn metaobjects:verify} runs the owned copies when the pom names them.
+ *
+ * <p>{@link EjectRoundTripTest} is the same proof for {@code names}. These two get their own
+ * because they were the two Java generators that could not be ejected: {@code entity}'s
+ * class body is emitted by writer classes outside the generator, and {@code extractor} was
+ * not a generator a pom could name.</p>
+ */
+public class EntityExtractorEjectRoundTripTest {
+
+    private static final String OWNED_PACKAGE = "com.acme.codegen";
+    private static final String OWNED_ENTITY = OWNED_PACKAGE + ".JavaObjectCodeGenerator";
+    private static final String OWNED_EXTRACTOR = OWNED_PACKAGE + ".ExtractorCodeGenerator";
+
+    /** Every file {@code -Dnames=entity,extractor} writes: the two generators, the bases
+     *  {@code entity} extends, and the writers that emit the class body. */
+    private static final List<String> OWNED_FILES = List.of(
+            "JavaObjectCodeGenerator.java", "ExtractorCodeGenerator.java",
+            "JavaCodeGenerator.java", "BaseObjectCodeGenerator.java",
+            "BaseObjectCodeWriter.java", "JavaCodeWriter.java",
+            "PojoAwareCodeWriter.java", "ValueObjectCodeWriter.java");
+
+    @Rule
+    public TemporaryFolder tempFolder = new TemporaryFolder();
+
+    private MetaDataLoader loader;
+    private Path fitness;
+    private URLClassLoader ownedClasses;
+
+    @Before
+    public void setUp() throws IOException {
+        fitness = findFitnessFixture();
+        URI uri = URIHelper.toURI("model:file:" + fitness.toAbsolutePath().toString().replace('\\', '/'));
+        loader = new MetaDataLoader(
+                LoaderOptions.create(false, false, true),
+                MetaDataLoader.SUBTYPE_MANUAL, "entity-extractor-eject-roundtrip");
+        loader.setSourceURIs(List.of(uri));
+        loader.init();
+    }
+
+    @After
+    public void closeOwnedClasses() throws IOException {
+        if (ownedClasses != null) ownedClasses.close();
+    }
+
+    /** Walk up from the test's working dir to the repo root. */
+    private static Path findFitnessFixture() {
+        Path dir = Path.of(System.getProperty("user.dir")).toAbsolutePath().normalize();
+        for (Path p = dir; p != null; p = p.getParent()) {
+            Path candidate = p.resolve("fixtures/persistence-conformance/canonical/meta.fitness.json");
+            if (Files.exists(candidate)) return candidate;
+        }
+        throw new IllegalStateException(
+                "could not locate fixtures/persistence-conformance/canonical/meta.fitness.json from " + dir);
+    }
+
+    // ------------------------------------------------------------------------------------
+    // harness
+    // ------------------------------------------------------------------------------------
+
+    private MetaDataEjectMojo ejectMojo(Path projectDir) {
+        MavenProject project = Mockito.mock(MavenProject.class);
+        Mockito.when(project.getBasedir()).thenReturn(projectDir.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());
+        MetaDataEjectMojo mojo = new MetaDataEjectMojo();
+        mojo.project = project;
+        return mojo;
+    }
+
+    /** Eject both generators with {@code -Dport=java}; returns the owned source directory. */
+    private Path ejectBoth(Path projectDir) throws Exception {
+        MetaDataEjectMojo mojo = ejectMojo(projectDir);
+        mojo.names = "entity,extractor";
+        mojo.port = "java";
+        mojo.execute();
+        Path dir = projectDir.resolve("codegen/src/main/java/com/acme/codegen");
+        try (Stream<Path> files = Files.list(dir)) {
+            assertEquals(OWNED_FILES.stream().sorted().collect(Collectors.toList()),
+                    files.map(f -> f.getFileName().toString()).sorted().collect(Collectors.toList()));
+        }
+        return dir;
+    }
+
+    /** Compile the owned copies against the published jars, as the adopter's module would. */
+    private URLClassLoader compileOwned(Path ownedDir) throws Exception {
+        List<File> sources;
+        try (Stream<Path> files = Files.list(ownedDir)) {
+            sources = files.filter(p -> p.toString().endsWith(".java")).map(Path::toFile)
+                    .collect(Collectors.toList());
+        }
+        Path classes = tempFolder.newFolder().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()));
+            boolean ok = javac.getTask(null, fm, diagnostics,
+                    List.of("-classpath", System.getProperty("java.class.path")), null,
+                    fm.getJavaFileObjectsFromFiles(sources)).call();
+            StringBuilder errs = new StringBuilder();
+            for (Diagnostic<? extends JavaFileObject> d : diagnostics.getDiagnostics()) errs.append(d).append('\n');
+            assertTrue("owned copies failed to compile:\n" + errs, ok);
+        }
+        ownedClasses = new URLClassLoader(new URL[]{classes.toUri().toURL()},
+                Thread.currentThread().getContextClassLoader());
+        return ownedClasses;
+    }
+
+    private static Generator owned(ClassLoader classes, String classname) throws Exception {
+        return (Generator) Class.forName(classname, true, classes).getDeclaredConstructor().newInstance();
+    }
+
+    /** Run {@code generator} over the corpus into a fresh directory; every file it wrote. */
+    private Map<String, String> generate(Generator generator, Map<String, String> args) throws IOException {
+        Path out = tempFolder.newFolder().toPath();
+        Map<String, String> all = new HashMap<>(args);
+        all.put("outputDir", out.toString());
+        generator.setArgs(all);
+        generator.execute(loader);
+        return tree(out);
+    }
+
+    private static Map<String, String> tree(Path root) throws IOException {
+        Map<String, String> out = new TreeMap<>();
+        try (Stream<Path> walk = Files.walk(root)) {
+            for (Path p : walk.filter(Files::isRegularFile).collect(Collectors.toList())) {
+                out.put(root.relativize(p).toString().replace('\\', '/'),
+                        Files.readString(p, StandardCharsets.UTF_8));
+            }
+        }
+        return out;
+    }
+
+    private static void assertSameTree(String label, Map<String, String> packaged, Map<String, String> owned) {
+        assertEquals(label + ": same set of generated files",
+                new ArrayList<>(packaged.keySet()), new ArrayList<>(owned.keySet()));
+        for (Map.Entry<String, String> e : packaged.entrySet()) {
+            assertEquals(label + ": content differs for " + e.getKey(), e.getValue(), owned.get(e.getKey()));
+        }
+    }
+
+    private static final Map<String, String> POJO = Map.of("type", "class", "flavor", "pojoAware");
+
+    // ------------------------------------------------------------------------------------
+    // the unchanged copy writes what the packaged generator writes
+    // ------------------------------------------------------------------------------------
+
+    @Test
+    public void anUnchangedEjectedEntityWritesWhatThePackagedOneWritesInEveryFlavor() throws Exception {
+        ClassLoader classes = compileOwned(ejectBoth(tempFolder.newFolder("adopter").toPath()));
+
+        Map<String, Map<String, String>> flavors = new TreeMap<>();
+        flavors.put("pojoAware", POJO);
+        flavors.put("valueObject", Map.of("type", "class", "flavor", "valueObject"));
+        flavors.put("interface", Map.of("type", "interface"));
+        // Naming args are read by the generator and by the writer it builds; a copy that
+        // dropped one would land its classes somewhere else.
+        flavors.put("pojoAware, renamed", Map.of("type", "class", "flavor", "pojoAware",
+                "pkgPrefix", "com.example", "pkgSuffix", "model", "namePrefix", "My", "nameSuffix", "Vo"));
+
+        for (Map.Entry<String, Map<String, String>> flavor : flavors.entrySet()) {
+            Map<String, String> packaged = generate(new JavaObjectCodeGenerator(), flavor.getValue());
+            Map<String, String> copy = generate(owned(classes, OWNED_ENTITY), flavor.getValue());
+            assertTrue(flavor.getKey() + ": the corpus generated only " + packaged.size() + " files",
+                    packaged.size() >= 17);
+            assertSameTree(flavor.getKey(), packaged, copy);
+        }
+    }
+
+    @Test
+    public void anUnchangedEjectedExtractorWritesWhatThePackagedOneAndEntityWrite() throws Exception {
+        ClassLoader classes = compileOwned(ejectBoth(tempFolder.newFolder("adopter").toPath()));
+
+        Map<String, String> packaged = generate(new ExtractorCodeGenerator(), Map.of());
+        Map<String, String> copy = generate(owned(classes, OWNED_EXTRACTOR), Map.of());
+        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);
+    }
+
+    // ------------------------------------------------------------------------------------
+    // an edit to the copy shows in its output
+    // ------------------------------------------------------------------------------------
+
+    @Test
+    public void anEditToEachOwnedCopyShowsInItsOutput() throws Exception {
+        Path ownedDir = ejectBoth(tempFolder.newFolder("adopter").toPath());
+        edit(ownedDir.resolve("JavaObjectCodeGenerator.java"),
+                " * GENERATED — self-registering ", " * GENERATED (owned entity copy) — self-registering ");
+        edit(ownedDir.resolve("ExtractorCodeGenerator.java"),
+                " * GENERATED — extractor for {@code ", " * GENERATED (owned extractor copy) — extractor for {@code ");
+        ClassLoader classes = compileOwned(ownedDir);
+
+        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"));
+
+        Map<String, String> extractor = generate(owned(classes, OWNED_EXTRACTOR), Map.of());
+        assertTrue(extractor.get("fitness/ProgramExtractor.java").contains("GENERATED (owned extractor copy)"));
+    }
+
+    /**
+     * The class body is owned, not just the generator around it. Each of the four writers is
+     * edited where it emits, and each edit has to reach the output of the flavor that writer
+     * serves, with no subclass and no change to the owned generator.
+     */
+    @Test
+    public void anEditToEachOwnedWriterChangesTheClassBody() throws Exception {
+        Path ownedDir = ejectBoth(tempFolder.newFolder("adopter").toPath());
+        edit(ownedDir.resolve("BaseObjectCodeWriter.java"),
+                "\"MetaObject:               \" + mo.getName()", "\"MetaObject (owned base):  \" + mo.getName()");
+        edit(ownedDir.resolve("JavaCodeWriter.java"),
+                "println(true, \"// \"+comment);", "println(true, \"// owned: \"+comment);");
+        edit(ownedDir.resolve("PojoAwareCodeWriter.java"),
+                "\"return this.\" + fieldName + \";\"", "\"return this.\" + fieldName + \"; // owned pojo\"");
+        edit(ownedDir.resolve("ValueObjectCodeWriter.java"),
+                "holderName + \".getValue();\"", "holderName + \".getValue(); // owned value object\"");
+        ClassLoader classes = compileOwned(ownedDir);
+
+        Map<String, String> valueObject = Map.of("type", "class", "flavor", "valueObject");
+        String pojo = generate(owned(classes, OWNED_ENTITY), POJO).get("fitness/Program.java");
+        assertTrue(pojo, pojo.contains(" * MetaObject (owned base):  fitness::Program"));
+        assertTrue(pojo, pojo.contains("// owned: Methods for MetaField: "));
+        assertTrue(pojo, pojo.contains("; // owned pojo"));
+        String vo = generate(owned(classes, OWNED_ENTITY), valueObject).get("fitness/Program.java");
+        assertTrue(vo, vo.contains(".getValue(); // owned value object"));
+        assertTrue(vo, vo.contains(" * MetaObject (owned base):  fitness::Program"));
+
+        // The packaged generator still writes through the packaged writers.
+        for (Map<String, String> flavor : List.of(POJO, valueObject)) {
+            String packaged = generate(new JavaObjectCodeGenerator(), flavor).get("fitness/Program.java");
+            assertTrue(packaged, packaged.contains(" * MetaObject:               fitness::Program"));
+            assertFalse(packaged, packaged.contains("// owned"));
+        }
+    }
+
+    /**
+     * The owned extractor reads each class name from the owned writer, so a rename there
+     * moves the extractor with the class it casts to. Read from the packaged writer, it
+     * would go on naming a class the owned {@code entity} no longer writes.
+     */
+    @Test
+    public void theOwnedExtractorNamesItsClassesThroughTheOwnedWriter() throws Exception {
+        Path ownedDir = ejectBoth(tempFolder.newFolder("adopter").toPath());
+        edit(ownedDir.resolve("JavaCodeWriter.java"),
+                "return GeneratorUtil.toCamelCase(name, true);\n    }\n\n    @Override\n    protected void writeGetter",
+                "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");
+        assertTrue(program, program.contains("public class ProgramRow extends "));
+
+        Map<String, String> extractors = generate(owned(classes, OWNED_EXTRACTOR), Map.of());
+        String extractor = extractors.get("fitness/ProgramRowExtractor.java");
+        assertTrue(String.valueOf(extractors.keySet()), extractor != null);
+        assertTrue(extractor, extractor.contains("public static ProgramRow extract("));
+    }
+
+    private static void edit(Path source, String from, String to) throws IOException {
+        String original = Files.readString(source, StandardCharsets.UTF_8);
+        assertTrue(source.getFileName() + " no longer holds: " + from, original.contains(from));
+        Files.writeString(source, original.replace(from, to), StandardCharsets.UTF_8);
+    }
+
+    // ------------------------------------------------------------------------------------
+    // -Dlist and the eject report
+    // ------------------------------------------------------------------------------------
+
+    private static String logged(Log log) {
+        ArgumentCaptor<CharSequence> captor = ArgumentCaptor.forClass(CharSequence.class);
+        Mockito.verify(log, Mockito.atLeastOnce()).info(captor.capture());
+        return captor.getAllValues().stream().map(CharSequence::toString).collect(Collectors.joining("\n"));
+    }
+
+    private String list(Path projectDir) throws Exception {
+        MetaDataEjectMojo mojo = ejectMojo(projectDir);
+        mojo.list = true;
+        Log log = Mockito.mock(Log.class);
+        mojo.setLog(log);
+        mojo.execute();
+        return logged(log);
+    }
+
+    private static String row(String listing, String name) {
+        return listing.lines().filter(l -> l.startsWith("  " + name + " [java]")).findFirst()
+                .orElseThrow(() -> new AssertionError("no [java] row for " + name + " in:\n" + listing));
+    }
+
+    @Test
+    public void theListingReportsBothAsEjectableAndMarksTheirOwnedCopies() throws Exception {
+        Path projectDir = tempFolder.newFolder("adopter").toPath();
+
+        String before = list(projectDir);
+        for (String name : List.of("entity", "extractor")) {
+            assertFalse(row(before, name), row(before, name).contains("not ejectable"));
+            assertFalse(row(before, name), row(before, name).contains("[owned"));
+        }
+        // The one Java generator with nothing to own keeps saying so.
+        assertTrue(row(before, "template"), row(before, "template").contains("not ejectable"));
+
+        Path ownedDir = ejectBoth(projectDir);
+        String owned = list(projectDir);
+        assertTrue(row(owned, "entity"), row(owned, "entity").endsWith("[owned — identical]"));
+        assertTrue(row(owned, "extractor"), row(owned, "extractor").endsWith("[owned — identical]"));
+
+        edit(ownedDir.resolve("ExtractorCodeGenerator.java"),
+                " * GENERATED — extractor for {@code ", " * GENERATED (mine) — extractor for {@code ");
+        String edited = list(projectDir);
+        assertTrue(row(edited, "extractor"),
+                row(edited, "extractor").endsWith("[owned — DIFFERS: 1 behind, 1 of your own]"));
+        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.
+        edit(ownedDir.resolve("PojoAwareCodeWriter.java"),
+                "println(true, \"super(mo);\");", "println(true, \"super(mo); // mine\");");
+        String writerEdited = list(projectDir);
+        assertTrue(row(writerEdited, "entity"),
+                row(writerEdited, "entity").endsWith("[owned — DIFFERS: 1 behind, 1 of your own]"));
+        assertTrue(row(writerEdited, "extractor"),
+                row(writerEdited, "extractor").endsWith("[owned — DIFFERS: 1 behind, 1 of your own]"));
+    }
+
+    @Test
+    public void ejectingTheExtractorSaysHowToWireAGeneratorThePomMayNotNameYet() throws Exception {
+        MetaDataEjectMojo mojo = ejectMojo(tempFolder.newFolder("adopter").toPath());
+        mojo.names = "extractor";
+        mojo.port = "java";
+        Log log = Mockito.mock(Log.class);
+        mojo.setLog(log);
+        mojo.execute();
+
+        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"));
+    }
+
+    @Test
+    public void bothNamesNeedAPortBecauseKotlinEjectsThemToo() throws Exception {
+        MetaDataEjectMojo mojo = ejectMojo(tempFolder.newFolder("adopter").toPath());
+        mojo.names = "entity,extractor";
+        try {
+            mojo.execute();
+            fail("expected a refusal naming both ports");
+        } catch (MojoFailureException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("\"entity\" is ejectable on more than one port"));
+            assertTrue(e.getMessage(), e.getMessage().contains("\"extractor\" is ejectable on more than one port"));
+        }
+    }
+
+    // ------------------------------------------------------------------------------------
+    // the drift check runs the owned copies
+    // ------------------------------------------------------------------------------------
+
+    /** A generate goal whose project classpath holds the adopter's compiled codegen module. */
+    private MetaDataGeneratorMojo generateGoal(ClassLoader classes) {
+        return new MetaDataGeneratorMojo() {
+            @Override protected ClassLoader createProjectClassLoader() { return classes; }
+        };
+    }
+
+    private MetaDataVerifyMojo verifyGoal(ClassLoader classes) {
+        return new MetaDataVerifyMojo() {
+            @Override protected ClassLoader createProjectClassLoader() { return classes; }
+        };
+    }
+
+    /** A pom that names the owned copies: entity with a concrete flavor, and the extractor. */
+    private void configure(AbstractMetaDataMojo mojo, Path outputDir) {
+        mojo.setLoader(LoaderParam.builder("entity-extractor-drift")
+                .withClassname("com.metaobjects.loader.MetaDataLoader")
+                .withSourceDir(fitness.getParent().toString())
+                .withSource(fitness.getFileName().toString())
+                .build());
+        List<GeneratorParam> generators = new ArrayList<>();
+        generators.add(GeneratorParam.builder(OWNED_ENTITY)
+                .withArg("outputDir", outputDir.toString())
+                .withArg("type", "class")
+                .withArg("flavor", "pojoAware")
+                .build());
+        generators.add(GeneratorParam.builder(OWNED_EXTRACTOR)
+                .withArg("outputDir", outputDir.toString())
+                .build());
+        mojo.setGenerators(generators);
+        mojo.setGlobals(Collections.emptyMap());
+    }
+
+    @Test
+    public void theDriftCheckRunsTheOwnedCopiesAndReportsWhatTheyNoLongerProduce() throws Exception {
+        Path ownedDir = ejectBoth(tempFolder.newFolder("adopter").toPath());
+        // Both copies are edited, so output from the PACKAGED generators would read as drift:
+        // an in-sync verdict below can only come from the copies having been the ones run.
+        edit(ownedDir.resolve("JavaObjectCodeGenerator.java"),
+                " * GENERATED — self-registering ", " * GENERATED (owned entity copy) — self-registering ");
+        edit(ownedDir.resolve("ExtractorCodeGenerator.java"),
+                " * GENERATED — extractor for {@code ", " * GENERATED (owned extractor copy) — extractor for {@code ");
+        ClassLoader classes = compileOwned(ownedDir);
+
+        Path committed = generatedInSync(classes);
+
+        // One emitter per file: with the extractor in <generators>, entity left them to it.
+        assertTrue(Files.readString(committed.resolve("fitness/ProgramExtractor.java"))
+                .contains("GENERATED (owned extractor copy)"));
+        assertTrue(Files.readString(committed.resolve(
+                "com/metaobjects/generated/GeneratedObjectClassBindingProvider.java"))
+                .contains("GENERATED (owned entity copy)"));
+
+        // What the packaged generators write is drift against the owned copies.
+        Files.writeString(committed.resolve("fitness/ProgramExtractor.java"),
+                generate(new ExtractorCodeGenerator(), Map.of()).get("fitness/ProgramExtractor.java"),
+                StandardCharsets.UTF_8);
+        MetaDataVerifyMojo verify = verifyGoal(classes);
+        configure(verify, committed);
+        try {
+            verify.execute();
+            fail("expected content drift on the extractor the owned copy no longer writes that way");
+        } catch (MojoFailureException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("[content-differs]"));
+            assertTrue(e.getMessage(), e.getMessage().contains("ProgramExtractor.java"));
+        }
+    }
+
+    /**
+     * Generate with the owned copies, let the wall clock move on to a later second, and
+     * confirm the drift check finds nothing to report.
+     *
+     * <p>The wait is the point. The verify goal compares bytes, and each class header used
+     * to carry a {@code Generated On:} line at second resolution, so the goal reported every
+     * class file as drifted unless it ran in the same second as the generate it checked.
+     * Generated output carries no clock now, and a verify on an unchanged model has to pass
+     * whenever it runs.</p>
+     */
+    private Path generatedInSync(ClassLoader classes) throws Exception {
+        Path committed = tempFolder.newFolder().toPath();
+        MetaDataGeneratorMojo gen = generateGoal(classes);
+        configure(gen, committed);
+        gen.execute();
+
+        long generatedIn = System.currentTimeMillis() / 1000;
+        while (System.currentTimeMillis() / 1000 == generatedIn) {
+            Thread.sleep(50);
+        }
+
+        MetaDataVerifyMojo verify = verifyGoal(classes);
+        configure(verify, committed);
+        verify.execute();
+        return committed;
+    }
+}
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 5d3e1b1fb..e37aac8c1 100644
--- a/spec/decisions/ADR-0022-codegen-and-docs-surface-architecture.md
+++ b/spec/decisions/ADR-0022-codegen-and-docs-surface-architecture.md
@@ -131,6 +131,9 @@ asserts it, with the one legitimate exception PINNED: `extractor` is fused into
 this port (`JavaObjectCodeGenerator.execute` emits it), so its output ships but it is not
 separately wirable.
 
+_Update 2026-10-11: that exception is gone. `ExtractorCodeGenerator` is a wirable generator
+and the pinned set is empty ([ADR-0034](ADR-0034-codegen-scaffold-and-own.md) Amendment 6)._
+
 ## Consequences
 
 - One canonical place for the codegen + docs architecture (this ADR). A
diff --git a/spec/decisions/ADR-0034-codegen-scaffold-and-own.md b/spec/decisions/ADR-0034-codegen-scaffold-and-own.md
index 2e187e5df..bccaa235e 100644
--- a/spec/decisions/ADR-0034-codegen-scaffold-and-own.md
+++ b/spec/decisions/ADR-0034-codegen-scaffold-and-own.md
@@ -346,3 +346,111 @@ fails at call time (the resolver sits in the eject module, which this change did
 the guide says to name an instance or a factory function.
 
 Guide: `docs/recipes/write-your-own-generator.md`.
+
+### Amendment 6 (2026-10-11) — the Java `entity` and `extractor` generators are ejectable
+
+**Ruling (maintainer).** Asked whether adopters may import the stock generators again:
+*"Yes, everything should be ejectable."* An audit of every stock generator in all five ports
+then found eight that could not be ejected, and the ruling on it was to make all of them
+ejectable except `template`. This amendment is the Java part: `entity`
+(`JavaObjectCodeGenerator`) and `extractor` (`ExtractorCodeGenerator`), both in
+`metaobjects-codegen-base`.
+
+**Why they could not be ejected.** The short form was "they share internal writer classes".
+There were two separate defects behind it.
+
+- **`entity` is not one class.** `JavaObjectCodeGenerator` selects a flavor and writes the
+  binding provider. Each class body is emitted by a writer (`BaseObjectCodeWriter` and its
+  three subclasses), and the arguments and the place each file lands come from two bases.
+  The generator also called two `protected` naming steps on a writer it does not extend and
+  named its sibling classes by bare name, which compiles only inside the writers' package.
+  So a copy of the one file did not compile, and a copy that did would have owned none of
+  the emit.
+- **`extractor` was not a generator.** It was a step `entity` ran. No `<generator>` entry
+  could name it, so an owned copy had nowhere to be wired, `-Dlist` had nothing to compare
+  and `mvn metaobjects:verify` had nothing to run.
+
+**Decision 1: the owned `entity` is the generator and everything that emits the class
+body.** Eject copies seven files into one owned package: `JavaObjectCodeGenerator`;
+`JavaCodeGenerator` and `BaseObjectCodeGenerator`, the bases that parse its arguments and
+place each file; and the writers `BaseObjectCodeWriter`, `JavaCodeWriter`,
+`PojoAwareCodeWriter` and `ValueObjectCodeWriter`. The registry declares the set
+(`GeneratorInfo.ejectWith()`). Eject makes one edit beyond the package rename, and it is the
+same rename seen from the importing side: an import of a class copied along is pointed at
+the copy. The owned generator therefore extends and constructs owned classes only, and a
+field, a constructor or an accessor is changed by editing the writer. Nothing is
+subclassed.
+
+What the copies still extend in the package is `MultiFileDirectGeneratorBase` (the
+one-file-per-object loop and the write guard) and `FileDirectWriter` (indentation and
+`println`). Neither holds emit of its own; they are to this generator what `GeneratorBase`
+is to every other ejected one.
+
+The first draft of this amendment copied `JavaObjectCodeGenerator.java` alone and named the
+writers supported surface to subclass. The maintainer ruled that out. `template` is
+excluded because it has no emit logic to own, and a generator shell whose class body stays
+in the package is that exclusion under another name. Every other ejected Java generator
+carries its own emit, and this one now does. The two bases come along for a concrete
+reason: they are typed to the writer (`createWriter` returns one, `writeSingleFile` casts to
+it), so a copy that extended the packaged bases could not hand them an owned writer, and
+where a file lands is computed there from the same naming arguments the writer reads.
+
+`extractor` copies `ExtractorCodeGenerator`, which holds its emit, with `JavaCodeWriter` and
+`BaseObjectCodeWriter`, where it reads the package and class name of the type each extractor
+casts to. Ejected into the same package as `entity`, the two generators share that one
+copy, so a naming change is made once and both follow it.
+
+**Decision 2: the naming steps stay `protected`, and no public view of them is added.** Both
+generators name each generated type by calling `getLanguagePackage` and `getClassName` on a
+`JavaCodeWriter`. That call compiles only in the writer's own package, which is why a lone
+copy of the generator did not compile. Decision 1 removes the cause: `JavaCodeWriter` is
+copied with each generator into the same package, so the call compiles in the copy as it
+does in the reference. An earlier draft added public `javaPackageOf` / `javaClassNameOf`
+methods for a generator in another package to call. Nothing is in another package any more,
+so they were removed before release rather than shipped as a second name for each step.
+
+**Decision 3: `extractor` is a generator of its own, and `entity` still writes its files
+when nothing else will.** `ExtractorCodeGenerator` implements `Generator`: a `<generator>`
+entry can name it, with the same naming args as `entity`. A pom that wires only `entity`
+must keep emitting what it did, so `entity` still writes the extractors by default. What
+decides between them is the run, not the adopter: the Maven plugin builds the whole
+generator list before running any of it, and when a generator in it implements
+`EmitsObjectExtractors` it sets `emitExtractors=false` on the others. That is the
+aggregation `useNames` already uses, with one difference: it is set whatever the pom says.
+`useNames` is a preference a pom may pin either way. With a separate extractor in the run,
+`entity` writing the same files is the duplicate, so there is no second value to honour.
+Without the derivation, an owned extractor wired beside `entity` would be a second emitter
+of the same files: identical output would hide the duplicate, and the first edit to the
+copy would fail the build as an output path collision.
+
+**Decision 4: a generated class header holds nothing that varies between runs or between
+copies.** The header comment of each class `entity` writes lost two lines. `Generated On:`
+held the wall-clock second of the run. `mvn metaobjects:verify` compares bytes, so it
+reported every class file as drifted unless it ran in the same second as the generate it
+checked, and the drift gate could not be used on this generator's output at all.
+`ObjectCodeWriter:` named the writer's class, which differs between a packaged writer and
+an owned copy of it, so an unchanged copy would not have emitted the packaged bytes. That
+line is dropped, not replaced by the generator's stable name: dropping it is the smaller
+change, and it tells a reader of the class nothing the `extends` clause does not.
+
+**What does not change.**
+
+- **Packaged output, apart from those two header lines.** A pom that wires `entity`, with
+  or without `flavor`, emits what it did less the two lines, so every regenerated class
+  file differs once, in its header comment only. `ExtractorCodeGenerator.emit(...)` and its
+  `protected` steps keep their signatures.
+- **The core and helper line of Amendment 3.** Both generators are reference helpers, owned
+  with `mvn metaobjects:eject -Dnames=entity,extractor -Dport=java`.
+- **`template`.** It stays not ejectable in every port that ships it. It is the Mustache
+  primitive: the template the adopter supplies is its emit logic.
+
+**Proof.** `EjectedBaseGeneratorsCompileTest` compiles each generator's copy set in one
+package against the module's public API. `EntityExtractorEjectRoundTripTest` ejects both
+through the mojo, compiles them, and requires the unchanged copies to emit the packaged
+generators' bytes over the persistence corpus in every flavor, with no line masked. It
+requires an edit to each owned writer to reach the class body, and a rename in the owned
+writer to move the owned extractor with it. It holds `-Dlist` to one verdict over a
+generator and the classes copied with it, and `mvn metaobjects:verify` to passing on the
+owned copies' output when it runs in a later second than the generate.
+`StandaloneExtractorGeneratorTest` and `EmitExtractorsDerivationTest` hold the split
+between the two generators.