Merge origin/main: integrate consolidation + Phase B; preserve migrate-ts reference-snapshot work

Local main diverged at the R6-Plan-2 merge and accumulated 11 commits
(migrate-ts reference-snapshot foundation + an omdb view-auto-creation
removal) while origin advanced 88 commits (schema-authority consolidation,
normalization-conformance Phase B, flavored-object codegen).

Conflict resolution: the omdb schema-bootstrap layer evolved divergently.
origin/main is authoritative (validator service removed; the Java integration
suite provisions schema from the canonical DDL). Took origin/main's version
for the entire omdb surface the local view-removal commit touched (12 files)
and accepted its deletion of the validator service, keeping that layer
internally consistent. The migrate-ts reference-snapshot commits merged
cleanly and are preserved. The local view-auto-creation cleanup is superseded
by origin's consolidation; it can be re-done against the new base as a small
follow-up.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: dmealing

.github/workflows/conformance.yml

@@ -43,22 +43,70 @@ jobs:
 
       - name: TypeScript conformance
         if: matrix.language == 'typescript'
-        run: bun install && cd server/typescript/packages/metadata && bun test test/conformance.test.ts test/yaml-conformance.test.ts
+        run: |
+          bun install
+          # Loader + YAML + object-model corpora (packages/metadata).
+          cd server/typescript/packages/metadata && bun test test/conformance.test.ts test/yaml-conformance.test.ts test/object-model-conformance.test.ts
+          # Byte-exact render / verify / recover / output-prompt corpora (packages/render).
+          cd ../render && bun test test/render-conformance.test.ts test/verify-conformance.test.ts test/recover/recover-conformance.test.ts test/output-prompt-conformance.test.ts
 
       - name: C# conformance
         if: matrix.language == 'csharp'
-        run: cd server/csharp && dotnet test MetaObjects.Conformance.Tests/MetaObjects.Conformance.Tests.csproj --nologo --verbosity quiet
+        run: |
+          # Loader + YAML + object-model corpora (Conformance.Tests project).
+          cd server/csharp && dotnet test MetaObjects.Conformance.Tests/MetaObjects.Conformance.Tests.csproj --nologo --verbosity quiet
+          # Byte-exact render / verify / recover / output-prompt corpora (Render.Tests project).
+          dotnet test MetaObjects.Render.Tests/MetaObjects.Render.Tests.csproj --nologo --verbosity quiet
 
       - name: Java conformance
         if: matrix.language == 'java'
-        run: cd server/java && mvn -pl metadata test -Dtest='ConformanceTest,YamlConformanceTest' -q
+        run: |
+          cd server/java
+          # Install metadata + render first to avoid the SNAPSHOT-resolution race
+          # ("No type registered for: field.uuid") when the render module's tests
+          # reference the freshly-built metadata artifact.
+          mvn -pl metadata,render -am install -DskipTests -q
+          # Loader + YAML + object-model corpora (metadata module).
+          mvn -pl metadata test -Dtest='ConformanceTest,YamlConformanceTest,ObjectModelConformanceTest' -q
+          # Byte-exact render / verify / recover / output-prompt corpora (render module).
+          mvn -pl render test -Dtest='RenderCrossPortReportTest,VerifyConformanceTest,RecoverConformanceTest,OutputPromptConformanceTest' -q
 
       - name: Python conformance
         if: matrix.language == 'python'
-        run: cd server/python && uv run pytest tests/conformance -q
+        run: |
+          cd server/python
+          # Loader + YAML corpora.
+          uv run pytest tests/conformance -q
+          # Byte-exact render / verify / recover / output-prompt corpora.
+          uv run pytest tests/render -q
+
+  conformance-kotlin:
+    # Kotlin (codegen-kotlin, KotlinPoet on the JVM) ships no loader / YAML /
+    # render / verify of its own — it reuses the shared JVM render engine. It
+    # runs only the corpora it actually has: object-model + output-prompt.
+    needs: fixture-lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '21'
+
+      - name: Kotlin conformance
+        run: |
+          cd server/java
+          # Build the metadata/render/codegen-kotlin chain first to avoid the
+          # SNAPSHOT-resolution race when the test module references freshly-built
+          # artifacts.
+          mvn -pl codegen-kotlin -am install -DskipTests -q
+          # object-model + output-prompt corpora (the only corpora Kotlin has).
+          mvn -pl codegen-kotlin test -Dtest='ObjectModelConformanceTest,OutputPromptConformanceTest' -q
 
   completeness-gate:
-    needs: conformance
+    needs: [conformance, conformance-kotlin]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4

.github/workflows/integration-tests.yml

@@ -6,19 +6,22 @@ name: integration-tests
 # run in parallel; any port red blocks the gate.
 #
 # Triggers:
-#   - pull_request to `main` — gates the default branch so persistence/api-contract
+#   - pull_request (any target branch) — gates every PR so persistence/api-contract
 #     drift can't merge green (these corpora are not covered by conformance.yml).
+#   - push to `main` — guards the default branch directly (e.g. forward-merges that
+#     land on main without going through a PR).
 #   - tag push matching v* (release gate, per docs/RELEASING.md).
 #   - manual dispatch (workflow_dispatch).
-# NOTE: this runs a 5-port Testcontainers matrix; if main-PR CI cost is too high,
-# narrow `pull_request.branches` or re-introduce an opt-in label.
+# NOTE: this runs a 5-port Testcontainers matrix on every PR; if CI cost is too
+# high, narrow `pull_request.branches` or re-introduce an opt-in label.
 
 on:
   push:
+    branches:
+      - main
     tags:
       - 'v*'
   pull_request:
-    branches: [main]
   workflow_dispatch:
 
 jobs:

CLAUDE.md

@@ -17,22 +17,22 @@ Equal weight — all four ship per-language today across the five ports (TS / C#
 
 ## Status
 
-_Last refreshed 2026-05-27._
+_Last refreshed 2026-05-30._
 
 **TypeScript reference implementation** is **published to npm at `0.7.0-rc.2`** (`@metaobjectsdev/*` packages, 12 packages on the `latest` tag). 2500+ tests passing across the workspace.
 
 **All five ports ship loader + canonical serializer + conformance + codegen + render + payload-VO + `verify`:**
 
 - **TypeScript** — `codegen-ts` (Vite-style plugins; Drizzle, Zod, Fastify) + `runtime-ts` + `migrate-ts` + the universal web client packages (`runtime-web`, `react`, `tanstack`).
-- **C#** — `MetaObjects` (loader + canonical serializer + conformance) + `MetaObjects.Render` (Mustache + payload-VO + `verify`) + `MetaObjects.Codegen` (EF Core entities + `AppDbContext` + CRUD minimal-API routes + Postgres DDL via full-CREATE and incremental introspect/diff/migrate). The `meta` CLI (`verify`/`gen`/`migrate`/`--from-db`) is the entry point.
-- **Java** — `metadata` + `omdb` + `om` + `dynamic` + `core-spring` + `metadata-ktx` (Kotlin facade) + `codegen-spring` (Spring controllers + DTOs + repositories + filter allowlists + payload records + output parsers) + `codegen-mustache` + `codegen-plantuml` + `render` + `maven-plugin` (`meta:gen`/`meta:editor`). FR-003 (OMDB runtime persistence + binding registry + typed jsonb + Spring-tx + source/origin metamodel) fully shipped, including Plan 4 (engine-debt remediation: atomic mapping cache, JDBC codec registry, `inTransaction` template). **Schema migrations are owned by the TypeScript toolchain** (`@metaobjectsdev/cli migrate`); the Java port's diff-and-converge migration engine and its `meta:migrate` / live-DB-drift `meta:verify` Maven goals were removed — OMDB retains runtime persistence + a dev/test runtime auto-create path (`MetaClassDBValidatorService` + the drivers' legacy `createTable` DDL) only.
-- **Python** — `metaobjects` (loader + canonical serializer + conformance + render + verify + codegen) + `migrate` + an `ObjectManager` runtime layer. All five conformance corpora green.
+- **C#** — `MetaObjects` (loader + canonical serializer + conformance) + `MetaObjects.Render` (Mustache + payload-VO + `verify`) + `MetaObjects.Codegen` (EF Core entities + `AppDbContext` + CRUD minimal-API routes). Schema migrations are TS-owned (ADR-0015): the C# migrate engine and the `migrate`/`--from-db` CLI surface were removed; the C# `meta` CLI is `verify`/`gen` only. EF Core runtime data-access stays per-port.
+- **Java** — `metadata` + `omdb` + `om` + `dynamic` + `core-spring` + `metadata-ktx` (Kotlin facade) + `codegen-spring` (Spring controllers + DTOs + repositories + filter allowlists + payload records + output parsers) + `codegen-mustache` + `codegen-plantuml` + `render` + `maven-plugin` (`meta:gen`/`meta:editor`). FR-003 (OMDB runtime persistence + binding registry + typed jsonb + Spring-tx + source/origin metamodel) fully shipped, including Plan 4 (engine-debt remediation: atomic mapping cache, JDBC codec registry, `inTransaction` template). **Schema migrations are owned by the TypeScript toolchain** (`@metaobjectsdev/cli migrate`); the Java port's diff-and-converge migration engine and its `meta:migrate` / live-DB-drift `meta:verify` Maven goals were removed, and per ADR-0015 Decision 2 the dev/test runtime auto-create path (`MetaClassDBValidatorService` + the drivers' `createTable`/`createIndex`/`createForeignKey`/`createSequence` DDL) is **also** removed — **OMDB is pure data-access** (CRUD/query/codec/transactions only).
+- **Python** — `metaobjects` (loader + canonical serializer + conformance + render + verify + codegen) + an `ObjectManager` runtime layer. The `migrate` module was removed (schema is TS-owned, ADR-0015); Python is pure data-access (codegen + ObjectManager runtime). All five conformance corpora green.
 - **Kotlin** — `codegen-kotlin` (KotlinPoet on JVM): entity + Exposed table + Spring controller + payload + relations + filter allowlist + validator + stored-proc + output-parser generators. `integration-tests-kotlin` runs the persistence-conformance corpus through Exposed against Testcontainers Postgres.
 
 **Cross-port conformance corpora** (every port runs the shared corpus):
 - Metamodel: `fixtures/conformance/` (~90 fixtures). TS / C# / Java / Python all green.
 - Render: `fixtures/render-conformance/`. TS / C# / Java / Kotlin / Python byte-identical.
-- Persistence: `fixtures/persistence-conformance/`. TS / C# / Java / Kotlin / Python all 12/12 against Testcontainers Postgres / Derby.
+- Persistence: `fixtures/persistence-conformance/`. **Query** scenarios run on every port (TS / C# / Java / Kotlin / Python), each provisioning its test DB by executing the committed, TS-produced `canonical/schema.postgres.sql` (Postgres only — Derby dropped for the cross-port query corpus, ADR-0015). The **migration** scenarios are exercised by **TS only** (TS owns schema migrations).
 - API-contract: `fixtures/api-contract-conformance/`. TS / C# / Java / Kotlin / Python all 20/20.
 - YAML / verify corpora green across the ports that ship those layers.