@@ -156,9 +156,10 @@ generator catalog and the Atlas evaluation are 1.2 work.
   - **`api-docs` is a generator you can own.** `dotnet meta eject api-docs` copies the page
     generator with its page model, builder, renderer and path math. `dotnet meta docs` hands
     off to `dotnet run --project codegen -- docs` once `codegen/generators/ApiDocsGenerator.cs`
-    exists, so your copy writes the reference. What the reference documents comes from the
-    generators in your `Program.cs` list: an owned `routes` whose `AppliesTo` you changed is
-    documented as it behaves, not as the packaged one does (`GeneratorApplicability.From`).
+    exists, so your copy writes the reference. What the reference documents is still what the
+    packaged generators emit for (`GeneratorApplicability.Packaged`): an owned `routes` whose
+    `AppliesTo` you changed is documented as the packaged one behaves, unless you edit the
+    owned builder.
     `dotnet meta gen` skips a docs generator and says so, and `verify --codegen` leaves it out.
     New public API in `MetaObjects.Codegen`: `IDocsGenerator`, `DocsRunFacts`,
     `GeneratorApplicability`, `GenContext.Applicability` and `GenContext.Docs`,
@@ -168,16 +169,27 @@ generator catalog and the Atlas evaluation are 1.2 work.
     `[Obsolete]` forwarder (see **Deprecated**).
   - **A copy you ejected before this release** keeps compiling and running: it finds the
     packaged emitters as it always did. `dotnet meta gen --list` now marks it as missing the
-    ones it was not handed (`Fr019SharedEnum.cs missing`). To own them, eject the same name
+    ones it was not handed (`Fr019SharedEnum.cs missing`). To own them, first raise the
+    `MetaObjects.Codegen` version in `codegen/Codegen.csproj` to 1.1.0 or later (the 1.1.0
+    emitter files are written against the 1.1.0 package, and some call API 1.0.x does not
+    have), then eject the same name
     into a scratch directory (`dotnet meta eject entity --root <scratch>`) and copy the emitter
     files from its `codegen/generators/` into yours; your copy and your edits are untouched,
     and it resolves the new files by namespace.
+  - **Eject warns about an older package pin.** Eject writes the sources of the tool you run
+    and never edits `codegen/Codegen.csproj`. When that file pins a `MetaObjects.Codegen` older
+    than the tool, `dotnet meta eject` now prints a warning with the pinned version, the
+    tool's version and the line to change; the owned project does not compile until the pin
+    is raised. A 1.0.x project needs this before `dotnet meta eject api-docs`, and before
+    re-ejecting `names`, `render-helper` or a prompt-tier generator.
   - **A gate for the rule.** For every ejectable generator the registry lists, a test ejects it
     alone, compiles it against the public API, fails on any reference to a packaged emitter,
     generator or docs writer outside a written engine surface, fails on a handed-over file
     nothing calls, and compares its output with the packaged generator's over the shared
     corpora. A registered generator with no eject source and no written exemption fails it, as
-    does a generator class the package ships that no registry entry builds.
+    does a generator class the package ships that no registry entry builds. A second test
+    compiles the package without the handed-over emitters, so nothing that stays packaged
+    calls one.
   The cross-port manifest lists `api-docs` for `csharp`.
 
 - **The stock `entity`, `queries`, `routes` and `barrel` generators are importable again
 
@@ -1021,7 +1021,11 @@ writes its output through come with it
 On first use eject also writes `codegen/Codegen.csproj`, a console project referencing
 `MetaObjects.Codegen` at the tool's version, and `codegen/Program.cs`, which lists your
 generators with `new` and calls the public runner. After that, both files are yours: eject
-never touches them again, even with `--force`, and prints what to add instead. Once
+never touches them again, even with `--force`, and prints what to add instead. That includes
+the package version: eject writes the sources of the tool you run, so when
+`codegen/Codegen.csproj` pins an older `MetaObjects.Codegen` than the tool, eject prints a
+warning with the pinned version, the tool's version and the line to change. The owned
+project does not compile until the pin is the tool's version or later. Once
 `codegen/Codegen.csproj` exists, `dotnet meta gen` and `dotnet meta verify --codegen` hand
 off to `dotnet run --project codegen` with the same arguments, so your owned generators
 run everywhere the tool did.
@@ -1074,11 +1078,15 @@ asks of the model (`FindInbound`, `TphPlan`, `InstanceArtifacts`, `ReportRows`).
 returns emitted text is handed over; a table or a model question is not. The line is written
 down and checked: a test ejects each generator the registry lists into an empty project,
 compiles it against the public API and fails on any reference to a packaged emitter, generator
-or docs writer that is not on that list.
+or docs writer that is not on that list. A second test compiles the package without the
+handed-over emitters, so nothing that stays packaged calls one.
 
 **A copy you ejected before the emitters were handed over** keeps compiling and running, with
-the packaged emitters. To own them, eject the same name into a scratch directory and copy the
-emitter files into your project; your copy and your edits are untouched:
+the packaged emitters. To own them, first raise the `MetaObjects.Codegen` version in
+`codegen/Codegen.csproj` to 1.1.0 or later: the 1.1.0 emitter files are written against the
+1.1.0 package, and some call API that 1.0.x does not have. Then eject the same name
+into a scratch directory and copy the emitter files into your project; your copy and your
+edits are untouched:
 
 ```bash
 scratch=$(mktemp -d)
@@ -1099,16 +1107,18 @@ Once `codegen/generators/ApiDocsGenerator.cs` exists, `dotnet meta docs` hands o
 `dotnet run --project codegen -- docs` with the same arguments, and the reference is written
 by your copy. A project that owns `codegen/` but not `api-docs` keeps the packaged reference:
 the hand-off for `docs` is keyed to the generator, not to the project, because an owned
-project pinned to an older `MetaObjects.Codegen` does not know the `docs` command.
-
-**It describes the generators you run.** The reference documents a route, an allowlist, a
-render helper only if the generator that emits it would. The packaged generators answer that
-through their static `AppliesTo`; when `docs` runs, the answers come from the generators in
-your `Program.cs` list instead, so an owned `routes` whose `AppliesTo` you changed is
-documented as it behaves. A generator you left in the package keeps answering as the package
-does. The builder asks through `GenContext.Applicability`
-(`GeneratorApplicability.From(list)` builds it), never through a generator class, which is
-why the copy depends on nothing but the engine.
+project pinned to an older `MetaObjects.Codegen` does not know the `docs` command. The owned
+copy needs `MetaObjects.Codegen` 1.1.0 or later for the same reason; eject warns when
+`codegen/Codegen.csproj` pins less.
+
+**It describes what the packaged generators emit.** The reference documents a route, an
+allowlist, a render helper only if the packaged generator that emits it would, which each
+answers through its static `AppliesTo`. That holds in a project that owns one of those
+generators too: an owned `routes` whose `AppliesTo` you changed is still documented as the
+packaged one behaves. To document your own surface, edit the owned builder
+(`CSharpApiModelBuilder.cs`), which is where the question is asked. The builder asks through
+`GenContext.Applicability` (`GeneratorApplicability.Packaged`), never through a generator
+class, which is why the copy depends on nothing but the engine.
 
 `Program.cs` lists `new ApiDocsGenerator()` beside the code generators. `dotnet meta gen` and
 `verify --codegen` skip it, and `gen` says so (`"api-docs" writes the api reference, so
 
@@ -81,7 +81,7 @@ for a worked example.
 
 ## Generate
 
-**Own a generator.** `dotnet meta eject <name>...` copies a reference generator into `codegen/generators/` and scaffolds an owned `codegen/` console project that `dotnet meta gen` then runs. Every generator `dotnet meta gen --list` shows is ejectable except `template`, the Mustache primitive, which has no emit logic of its own to own. An ejected generator comes with the emitters it writes its output through (the enum, navigation, doc-comment and prompt-tier writers), so the copy owns the code that writes the file and not a shell around the package's; the naming and type-mapping tables (`CSharpNaming`, `ValueObjectNames`) stay in the package as the engine. `dotnet meta eject api-docs` does the same for the api reference `dotnet meta docs` writes, and the reference then describes the generators you own. See [Own your codegen → C#](../features/own-your-codegen.md#c-dotnet-meta-eject).
+**Own a generator.** `dotnet meta eject <name>...` copies a reference generator into `codegen/generators/` and scaffolds an owned `codegen/` console project that `dotnet meta gen` then runs. Every generator `dotnet meta gen --list` shows is ejectable except `template`, the Mustache primitive, which has no emit logic of its own to own. An ejected generator comes with the emitters it writes its output through (the enum, navigation, doc-comment and prompt-tier writers), so the copy owns the code that writes the file and not a shell around the package's; the naming and type-mapping tables (`CSharpNaming`, `ValueObjectNames`) stay in the package as the engine. `dotnet meta eject api-docs` does the same for the api reference `dotnet meta docs` writes. Ejecting into a project whose `codegen/Codegen.csproj` pins an older `MetaObjects.Codegen` than the tool prints a warning naming the line to change. See [Own your codegen → C#](../features/own-your-codegen.md#c-dotnet-meta-eject).
 
 ```bash
 # Generate EF Core entities + AppDbContext + CRUD minimal-API routes
 
@@ -129,6 +129,93 @@ public void A_second_eject_of_a_different_generator_does_not_touch_the_existing_
         Assert.Contains("adopter's own edit", File.ReadAllText(Path.Combine(CodegenDir, "Program.cs")));
     }
 
+    private string CsprojPath => Path.Combine(CodegenDir, "Codegen.csproj");
+
+    /// <summary>Scaffold with this tool, then re-pin the owned project the way an older tool left it.</summary>
+    private string ScaffoldPinnedAt(string? version)
+    {
+        Assert.Equal(0, EjectCommand.Run(["entity"], _root, force: false).ExitCode);
+        var scaffolded = File.ReadAllText(CsprojPath);
+        var pin = $"Version=\"{EjectCommand.ToolVersion()}\"";
+        Assert.Contains(pin, scaffolded);
+        if (version is not null) File.WriteAllText(CsprojPath, scaffolded.Replace(pin, $"Version=\"{version}\""));
+        return File.ReadAllText(CsprojPath);
+    }
+
+    // Eject writes this tool's sources and never edits the owned project's package pin. A project
+    // scaffolded by an older tool therefore gets sources its pinned package cannot compile, and the
+    // only place that can say so before `dotnet run --project codegen` fails is eject's own report.
+    [Fact]
+    public void Ejecting_into_a_project_pinned_to_an_older_package_warns_and_names_the_line_to_change()
+    {
+        var csproj = ScaffoldPinnedAt("0.9.0");
+        var pinLine = Array.FindIndex(csproj.Split('\n'), l => l.Contains("PackageReference", StringComparison.Ordinal)) + 1;
+
+        var result = EjectCommand.Run(["api-docs"], _root, force: false);
+
+        Assert.Equal(0, result.ExitCode);
+        var warning = Assert.Single(result.Out, l => l.StartsWith("warning:", StringComparison.Ordinal));
+        Assert.Contains("MetaObjects.Codegen 0.9.0", warning);
+        Assert.Contains(EjectCommand.ToolVersion(), warning);
+        Assert.Contains("will not compile", warning);
+        Assert.Contains($"line {pinLine} of codegen/Codegen.csproj", warning);
+        Assert.Contains(
+            $"<PackageReference Include=\"MetaObjects.Codegen\" Version=\"{EjectCommand.ToolVersion()}\" />",
+            result.Out[result.Out.ToList().IndexOf(warning) + 1]);
+        Assert.Equal(csproj, File.ReadAllText(CsprojPath));
+    }
+
+    [Theory]
+    [InlineData(null)]                      // the pin this tool wrote: equal
+    [InlineData("99.0.0")]                  // newer
+    [InlineData("$(MetaObjectsVersion)")]   // not a version eject can read
+    [InlineData("[1.0.0,2.0.0)")]           // a range
+    public void Ejecting_into_a_project_whose_pin_is_not_older_says_nothing_about_it(string? version)
+    {
+        ScaffoldPinnedAt(version);
+
+        var result = EjectCommand.Run(["api-docs"], _root, force: false);
+
+        Assert.Equal(0, result.ExitCode);
+        Assert.DoesNotContain(result.Out, l => l.Contains("warning", StringComparison.OrdinalIgnoreCase));
+    }
+
+    [Fact]
+    public void Ejecting_into_a_project_with_no_package_pin_says_nothing_about_it()
+    {
+        ScaffoldPinnedAt(null);
+        File.WriteAllText(CsprojPath, "<Project Sdk=\"Microsoft.NET.Sdk\"><ItemGroup><ProjectReference Include=\"../x.csproj\" /></ItemGroup></Project>");
+
+        var result = EjectCommand.Run(["api-docs"], _root, force: false);
+
+        Assert.Equal(0, result.ExitCode);
+        Assert.DoesNotContain(result.Out, l => l.Contains("warning", StringComparison.OrdinalIgnoreCase));
+    }
+
+    // The order is semver.org's (§11), whose own worked chain is
+    // 1.0.0-alpha < 1.0.0-alpha.1 < 1.0.0-alpha.beta < 1.0.0-beta.2 < 1.0.0-beta.11 < 1.0.0-rc.1 < 1.0.0.
+    // A string or System.Version comparison gets the release candidate and the two-digit parts wrong.
+    [Theory]
+    [InlineData("1.0.13", "1.1.0", true)]
+    [InlineData("1.1.0-rc.1", "1.1.0", true)]
+    [InlineData("1.1.0", "1.1.0-rc.1", false)]
+    [InlineData("1.1.0", "1.1.0", false)]
+    [InlineData("1.1.0+8ef72c3", "1.1.0", false)]
+    [InlineData("1.9.0", "1.10.0", true)]
+    [InlineData("1.10.0", "1.9.0", false)]
+    [InlineData("1.0.0-alpha", "1.0.0-alpha.1", true)]
+    [InlineData("1.0.0-alpha.1", "1.0.0-alpha.beta", true)]
+    [InlineData("1.0.0-alpha.beta", "1.0.0-beta.2", true)]
+    [InlineData("1.0.0-beta.2", "1.0.0-beta.11", true)]
+    [InlineData("1.0.0-beta.11", "1.0.0-rc.1", true)]
+    [InlineData("1.0.0-rc.1", "1.0.0-beta.11", false)]
+    [InlineData("1.*", "1.1.0", false)]
+    [InlineData("$(MetaObjectsVersion)", "1.1.0", false)]
+    public void A_pin_is_older_by_semantic_version_precedence(string pinned, string required, bool older)
+    {
+        Assert.Equal(older, EjectCommand.IsOlderVersion(pinned, required));
+    }
+
     [Fact]
     public void Ejected_copy_is_content_identical_to_the_rewritten_reference()
     {
 
@@ -196,12 +196,12 @@ private void PointScaffoldAtThisCheckout(string repoRoot)
 
     /// <summary>
     /// An owned api-docs generator, run for real (ADR-0025 / ADR-0034 Amendment 3): eject `routes` and
-    /// `api-docs`, change what the owned routes serves, and run the owned project's `docs` command. The
-    /// reference is written by the OWNED api-docs copy and describes the OWNED routes, so the edit shows up
-    /// in the pages; and the same owned project's `gen` skips the docs generator and says so.
+    /// `api-docs`, add a page to the owned api-docs copy, and run the owned project's `docs` command. The
+    /// reference is written by the OWNED api-docs copy, so the added page is on disk beside the model's;
+    /// and the same owned project's `gen` skips the docs generator and says so.
     /// </summary>
     [Fact]
-    public void Owned_api_docs_writes_the_reference_and_describes_the_owned_routes()
+    public void Owned_api_docs_writes_the_reference()
     {
         var repoRoot = RepoRoot();
         Directory.CreateDirectory(MetadataDir);
@@ -221,24 +221,25 @@ public void Owned_api_docs_writes_the_reference_and_describes_the_owned_routes()
         Assert.True(CodegenHandoff.HasOwnedDocs(_root));
         PointScaffoldAtThisCheckout(repoRoot);
 
-        // The project's own decision: its routes serve no entity.
-        var routesPath = Path.Combine(_root, "codegen", "generators", "RoutesGenerator.cs");
-        var routes = File.ReadAllText(routesPath);
-        const string signature = "public static bool AppliesTo(MetaObject entity, MetaRoot root) =>";
-        Assert.Contains(signature, routes);
-        File.WriteAllText(routesPath, routes.Replace(
-            signature,
-            "public static bool AppliesTo(MetaObject entity, MetaRoot root) => false;\n" +
-            "    private static bool PackagedAppliesTo(MetaObject entity, MetaRoot root) =>"));
+        // The project's own edit: its reference carries a page the packaged generator does not write.
+        var apiDocsPath = Path.Combine(_root, "codegen", "generators", "ApiDocsGenerator.cs");
+        var apiDocs = File.ReadAllText(apiDocsPath);
+        const string lastPage = "yield return Page(facts, \"AGENT-API.md\", renderer.RenderAgentApi(model));";
+        Assert.Contains(lastPage, apiDocs);
+        File.WriteAllText(apiDocsPath, apiDocs.Replace(
+            lastPage,
+            lastPage + "\n        yield return Page(facts, \"OWNED.md\", \"written by the owned api-docs\");"));
 
         var docsOut = Path.Combine(_root, "docs");
         var (docsExit, docsOutput) = RunCodegenProject("docs", MetadataDir, "--out", docsOut, "--namespace", "Acme.Generated");
         Assert.True(docsExit == 0, $"docs failed (exit {docsExit}):\n{docsOutput}");
         Assert.Contains("api page(s) written", docsOutput);
 
         var widget = File.ReadAllText(Directory.GetFiles(docsOut, "Widget.md", SearchOption.AllDirectories).Single());
-        Assert.Contains("DbSet<Widget>", widget);              // the owned api-docs described the model…
-        Assert.DoesNotContain("GET /api/", widget);            // …and what the OWNED routes serve: nothing.
+        Assert.Contains("DbSet<Widget>", widget);
+        Assert.Equal(
+            "written by the owned api-docs",
+            File.ReadAllText(Directory.GetFiles(docsOut, "OWNED.md", SearchOption.AllDirectories).Single()));
 
         // The same owned project's gen leaves the docs generator out and says why.
         var (genExit, genOutput) = RunCodegenProject(
 
@@ -20,9 +20,12 @@ public static bool HasOwnedCodegen(string projectRoot) =>
 
     /// <summary>True iff <paramref name="projectRoot"/> owns the api-docs generator: the ejected
     /// codegen project exists AND carries <c>codegen/generators/ApiDocsGenerator.cs</c>. That file is
-    /// what `dotnet meta docs` hands off for — the project's own copy writes the reference, and the
-    /// owned project's package version is one that knows the <c>docs</c> command (a project
-    /// scaffolded before api-docs could be ejected has no such file, and its package does not).</summary>
+    /// what `dotnet meta docs` hands off for — the project's own copy writes the reference. Its
+    /// presence says a tool that can eject api-docs wrote it, NOT that the package
+    /// <c>codegen/Codegen.csproj</c> pins knows the <c>docs</c> command: eject never edits that pin, so
+    /// a project scaffolded by an older tool keeps the older one until its owner raises it, and
+    /// <see cref="EjectCommand.Run"/> warns when it writes into such a project. A project with no such
+    /// file never ejected api-docs, and <c>docs</c> stays with the packaged generator whatever it pins.</summary>
     public static bool HasOwnedDocs(string projectRoot) =>
         HasOwnedCodegen(projectRoot) &&
         MetaObjects.Codegen.GeneratorRegistry.Get("api-docs")?.SourceFileName is { } file &&