@@ -95,6 +95,52 @@ same blindness that let the original defect ship. `migrate-ts`'s `loadFixture` n
 loader errors instead of discarding them — a checked-in fixture had been declaring the
 illegal form and driving those suites green. All five ports green.
 
+### Fixed — the C# EF Core target had no foreign keys at all, so `@onDelete` was inert ([#294](https://github.com/metaobjectsdev/metaobjects/issues/294))
+
+**The issue reports that `DbContextGenerator` ignores `@onDelete`. It is worse than that:
+the generator emitted no 1:N relationship configuration whatsoever.** A generated entity
+carries a bare scalar FK property (`public long ProgramId`) and — since ADR-0038 replaced
+reverse navigation with explicit FK finders — no navigation property on either side. EF
+Core builds a relationship from a navigation or an explicit `HasOne`; with neither, it
+built **nothing**. `HasOne` appeared exactly once in the whole generated `AppDbContext`,
+inside the M:N `UsingEntity` call. So `modelBuilder.Entity<Week>().Metadata.GetForeignKeys()`
+returned an **empty collection**, and there was no foreign key for a delete behaviour to
+attach to — on a port where the database, whose DDL the TypeScript engine owns (ADR-0015),
+has carried `ON DELETE CASCADE` correctly all along.
+
+**Now every enforced `identity.reference` emits an explicit relationship with the action
+INLINE on the establishing call**, which is what the issue asks for and the reason is
+specific: EF reconciles TPH relationships *after* `OnModelCreating` returns and may replace
+the FK metadata object, so a later `GetForeignKeys().Single(...).DeleteBehavior = ...` is
+silently discarded. The adopter measured exactly that — 134 of 135 FKs took the mutation;
+the one that did not was a TPH base+subtype dual-declared FK, reading back as EF's
+convention default with nothing thrown. Configuring the relationship as it is *established*
+is durable by construction.
+
+The precedence is a **port of `migrate-ts`'s `referential-actions.ts`**, the cross-port SSOT,
+tier for tier: reference-level `@onDelete` → a correlated sibling relationship → the
+parent-side reverse relationship, package-aware (ADR-0042), with `@through` excluded, the
+more-than-one-reference-to-the-same-target ambiguity guard, and the inferred-`set-null`-on-
+NOT-NULL satisfiability guard. Three behaviours are decided rather than inherited: a TPH
+base and subtype declaring the **same** FK configure it **once**, on the base that owns the
+shared column (a duplicate is the ambiguity the adopter was working around); an M:N
+junction's FK sides ride on the `UsingEntity` call that creates them, so the per-reference
+pass skips junction entities rather than configuring one FK twice; and a resolved
+`set-null` over a `@required` FK **warns and emits no clause**, because EF fails MODEL
+VALIDATION there and would take down the entire `DbContext` rather than one relationship.
+`@onUpdate` is deliberately not surfaced — `DeleteBehavior` covers deletes only, so it
+remains a DDL-level fact.
+
+**The durable lesson is the familiar one: the thing that would have caught this did not
+exist.** [`docs/features/relationships.md`](docs/features/relationships.md) has shown the
+exact `HasOne<Author>().WithMany().HasForeignKey(...).OnDelete(DeleteBehavior.Cascade)`
+snippet as the C# port's output for releases, and nothing ever compared it to what the
+generator emits. A string assertion over generated source would not have closed it either —
+it passes just as happily for the post-hoc mutation that does not stick. The new gate builds
+the **real** EF model from the generated code and reads `DeleteBehavior` back off the
+finalized `IModel` (model-only, no container), and it was confirmed to fail without the fix
+with `Collection: []` — the empty FK set above.
+
 ### Fixed — `meta upgrade` rewrote nothing on a YAML estate, then called it clean ([#339](https://github.com/metaobjectsdev/metaobjects/issues/339))
 
 `meta upgrade` is the fixer for everything `0.24.0` retired. On a **YAML** estate it
 
@@ -238,13 +238,20 @@ KEY ... ON DELETE CASCADE` in the Postgres DDL.
 
 ```csharp
 // generated/AppDbContext.cs (excerpt)
-modelBuilder.Entity<Post>()
-    .HasOne<Author>()
-    .WithMany()
-    .HasForeignKey(p => p.AuthorId)
-    .OnDelete(DeleteBehavior.Cascade);
+modelBuilder.Entity<Post>().HasOne<Author>().WithMany()
+    .HasForeignKey(nameof(Post.AuthorId)).OnDelete(DeleteBehavior.Cascade);
 ```
 
+The action rides on the call that establishes the foreign key, never a later
+`GetForeignKeys(...)` mutation: EF Core reconciles TPH relationships *after*
+`OnModelCreating` returns and can replace the foreign-key metadata object, which
+silently discards a post-hoc assignment ([#294](https://github.com/metaobjectsdev/metaobjects/issues/294)).
+`WithMany()` is inverse-less because the port emits no reverse collection
+navigations at all — reverse traversal is the explicit FK finders of ADR-0038.
+
+`@onUpdate` has no EF Core representation (`DeleteBehavior` covers deletes only),
+so it stays a DDL-level fact emitted by the TypeScript-owned migration engine.
+
 ```sql
 -- emitted by `meta migrate`
 ALTER TABLE "posts"
 
@@ -0,0 +1,207 @@
+// #294 — the C# EF Core target emits explicit 1:N relationship configuration carrying
+// the ADR-0047 referential action.
+//
+// Before this, DbContextGenerator emitted NO relationship configuration for a plain
+// foreign key at all: the generated entity carries a bare scalar FK property and no
+// navigation, so EF Core built no relationship, GetForeignKeys() was empty, and every
+// DeleteBehavior fell back to EF's convention regardless of what the metadata — or the
+// database — said. @onDelete was inert on this port.
+//
+// These tests pin the RESOLUTION (the ADR-0047 precedence, ported from the migrate-ts
+// SSOT) and the EMISSION SHAPE. That the emitted model is durable through EF's own
+// finalization — the TPH failure the issue reports — is pinned separately by
+// Issue294EfModelDeleteBehaviorTests, which builds a real EF model and reads the
+// behavior back.
+
+using MetaObjects.Codegen;
+using MetaObjects.Codegen.Generators;
+using MetaObjects.Loader;
+using MetaObjects.Meta;
+using Xunit;
+
+namespace MetaObjects.Codegen.Tests;
+
+public class Issue294ReferentialActionTests
+{
+    // Program (parent, declares the to-many composition) / Week (owns the FK).
+    // The reference carries whatever @onDelete the test injects; the parent-side
+    // relationship is the documented authoring shape and drives tier-3 correlation.
+    // Tokens are substituted before parsing, so they never reach the JSON reader.
+    // (String tokens rather than interpolation: the model is dense in `}}`, which an
+    // interpolated raw string would read as an interpolation hole.)
+    private const string TwoEntityTemplate = """
+    { "metadata.root": { "package": "acme", "children": [
+      { "object.entity": { "name": "Program", "children": [
+        { "source.rdb": { "@table": "programs" } },
+        { "field.long": { "name": "id" } },
+        { "identity.primary": { "@fields": "id" } },
+        { "relationship.composition": { "name": "weeks", "@cardinality": "many", "@objectRef": "Week" } }
+      ]}},
+      { "object.entity": { "name": "Week", "children": [
+        { "source.rdb": { "@table": "weeks" } },
+        { "field.long": { "name": "id" } },
+        { "field.long": { "name": "programId"/*FK_ATTRS*/ } },
+        { "identity.primary": { "@fields": "id" } }/*WEEK_REL*/,
+        { "identity.reference": { "name": "refProgram", "@fields": "programId",
+          "@references": "Program"/*REF_ATTRS*/ } }
+      ]}}
+    ]}}
+    """;
+
+    private static string TwoEntityModel(
+        string referenceAttrs = "", string weekRelationship = "", string programIdAttrs = "") =>
+        TwoEntityTemplate
+            .Replace("/*REF_ATTRS*/", referenceAttrs)
+            .Replace("/*WEEK_REL*/", weekRelationship)
+            .Replace("/*FK_ATTRS*/", programIdAttrs);
+
+    private static (string Source, List<string> Warnings) Generate(string model)
+    {
+        var result = new MetaDataLoader().Load([new InMemoryStringSource(model, id: "issue-294.json")]);
+        Assert.Empty(result.Errors);
+
+        var warnings = new List<string>();
+        var ctx = new GenContext
+        {
+            Entities = result.Root.Objects(),
+            Root = result.Root,
+            Config = new GenConfig { OutDir = "/unused", Namespace = "Acme.Generated" },
+            Warn = warnings.Add,
+        };
+        var file = Assert.Single(new DbContextGenerator().Generate(ctx));
+        return (file.Content, warnings);
+    }
+
+    private static string WeekFkLine(string source) =>
+        Assert.Single(source.Split('\n'), l => l.Contains("HasOne<Program>()")).Trim();
+
+    [Fact]
+    public void A_plain_reference_now_configures_a_real_foreign_key()
+    {
+        var (source, _) = Generate(TwoEntityModel());
+        // The FK must be established by the config call itself — never a later
+        // GetForeignKeys() mutation, which TPH finalization can silently discard (#294).
+        Assert.Equal(
+            "modelBuilder.Entity<Week>().HasOne<Program>().WithMany()"
+            + ".HasForeignKey(nameof(Week.ProgramId)).OnDelete(DeleteBehavior.Cascade);",
+            WeekFkLine(source));
+        Assert.DoesNotContain("GetForeignKeys", source);
+    }
+
+    [Fact]
+    public void Tier1_an_action_on_the_reference_itself_wins()
+    {
+        var (source, _) = Generate(TwoEntityModel(referenceAttrs: """, "@onDelete": "restrict" """));
+        Assert.Contains(".OnDelete(DeleteBehavior.Restrict)", WeekFkLine(source));
+    }
+
+    [Fact]
+    public void Tier2_a_sibling_relationship_beats_the_parent_side_one()
+    {
+        // Week's own association (restrict) must win over Program's composition (cascade).
+        var (source, _) = Generate(TwoEntityModel(weekRelationship: """
+        ,{ "relationship.association": { "name": "program", "@cardinality": "one", "@objectRef": "Program" } }
+        """));
+        Assert.Contains(".OnDelete(DeleteBehavior.Restrict)", WeekFkLine(source));
+    }
+
+    [Fact]
+    public void Tier3_the_parent_side_composition_supplies_its_subtype_default()
+    {
+        // No action anywhere: the only source is Program's to-many composition, whose
+        // subtype default is cascade. This is the shape the authoring docs teach.
+        var (source, _) = Generate(TwoEntityModel());
+        Assert.Contains(".OnDelete(DeleteBehavior.Cascade)", WeekFkLine(source));
+    }
+
+    [Fact]
+    public void No_action_emits_no_clause_because_it_is_the_database_default()
+    {
+        var (source, _) = Generate(TwoEntityModel(referenceAttrs: """, "@onDelete": "no-action" """));
+        var line = WeekFkLine(source);
+        Assert.Contains("HasForeignKey(nameof(Week.ProgramId));", line);
+        Assert.DoesNotContain(".OnDelete(", line);
+    }
+
+    [Fact]
+    public void Set_null_over_a_required_fk_warns_instead_of_breaking_model_validation()
+    {
+        // EF fails MODEL VALIDATION for SetNull over a non-nullable FK, which would take
+        // down the entire DbContext rather than one relationship. Warn and omit.
+        var (source, warnings) = Generate(TwoEntityModel(
+            referenceAttrs: """, "@onDelete": "set-null" """,
+            programIdAttrs: ""","@required": true"""));
+
+        Assert.DoesNotContain(".OnDelete(", WeekFkLine(source));
+        Assert.Contains(warnings, w => w.Contains("SET NULL") && w.Contains("programId"));
+    }
+
+    [Fact]
+    public void A_logical_only_reference_configures_nothing()
+    {
+        // ADR-0046 — @enforce:false is a navigation-only reference with no FK at all.
+        var (source, _) = Generate(TwoEntityModel(referenceAttrs: """, "@enforce": false """));
+        Assert.DoesNotContain("HasOne<Program>()", source);
+    }
+
+    // A TPH base and one concrete subtype declaring the SAME foreign key — the exact
+    // shape #294 reports. The physical column is one column on the shared table, so it
+    // must be configured exactly ONCE; a duplicate configuration is what made the
+    // adopter's post-hoc mutation unreliable.
+    private const string TphDualDeclaration = """
+    { "metadata.root": { "package": "acme", "children": [
+      { "object.entity": { "name": "User", "children": [
+        { "source.rdb": { "@table": "users" } },
+        { "field.long": { "name": "id" } },
+        { "identity.primary": { "@fields": "id" } }
+      ]}},
+      { "object.entity": { "name": "Item", "@discriminator": "kind", "children": [
+        { "source.rdb": { "@table": "items" } },
+        { "field.long": { "name": "id" } },
+        { "field.enum": { "name": "kind", "@values": ["Alpha", "Beta"] } },
+        { "field.long": { "name": "senderId" } },
+        { "identity.primary": { "@fields": "id" } },
+        { "identity.reference": { "name": "refSender", "@fields": "senderId",
+          "@references": "User", "@onDelete": "cascade" } }
+      ]}},
+      { "object.entity": { "name": "AlphaItem", "extends": "Item", "@discriminatorValue": "Alpha",
+        "children": [
+        { "identity.reference": { "name": "refSenderAlpha", "@fields": "senderId",
+          "@references": "User", "@onDelete": "cascade" } }
+      ]}},
+      { "object.entity": { "name": "BetaItem", "extends": "Item", "@discriminatorValue": "Beta",
+        "children": [
+        { "field.string": { "name": "note", "@maxLength": 40 } }
+      ]}}
+    ]}}
+    """;
+
+    [Fact]
+    public void A_tph_base_and_subtype_declaring_the_same_fk_configure_it_once()
+    {
+        var (source, _) = Generate(TphDualDeclaration);
+        var fkLines = source.Split('\n').Where(l => l.Contains("HasOne<User>()")).ToList();
+
+        var line = Assert.Single(fkLines);
+        // Configured on the BASE, which owns the shared table's column.
+        Assert.Contains("modelBuilder.Entity<Item>()", line);
+        Assert.Contains(".OnDelete(DeleteBehavior.Cascade)", line);
+    }
+
+    [Fact]
+    public void A_model_with_no_enforced_reference_is_unchanged()
+    {
+        // Guards the byte-identical promise for models this feature does not touch.
+        var (source, _) = Generate("""
+        { "metadata.root": { "package": "acme", "children": [
+          { "object.entity": { "name": "Solo", "children": [
+            { "source.rdb": { "@table": "solos" } },
+            { "field.long": { "name": "id" } },
+            { "identity.primary": { "@fields": "id" } }
+          ]}}
+        ]}}
+        """);
+        Assert.DoesNotContain("HasOne<", source);
+        Assert.DoesNotContain("OnDelete(", source);
+    }
+}