Document client runtime conformance roles

Aetheria.State.Verify/Program.cs

@@ -59,6 +59,7 @@ RequireNoDeadPopupShells(root);
 RequirePlayerSettingsEveSurface(root);
 RequireVerseHostSettingsAuthority(root);
 RequireClientTargetBootAuthority(root);
+RequireClientRuntimeConformanceContract(root);
 RequireVerseReplicaTool(root);
 RequireVerseSettingsShellAndBridge(root);
 RequireTypedStatRecipeOperations(root);
@@ -604,6 +605,7 @@ Console.WriteLine("NameTools editor shell: the remaining name helper window lowe
 Console.WriteLine("Verse client state authority: Unity gameplay/UI read typed state through the shared Verse client instead of direct store spelunking");
 Console.WriteLine("Verse host authority: daemon-owned typed verse host settings now drive provider advertisement, operations telemetry, and served Verse discovery");
 Console.WriteLine("Client target boot authority: Unity boot resolves the active Verse through a typed client target instead of local path folklore");
+Console.WriteLine("Client runtime conformance: Hermodr is the generic Eve RTS check; Godot is the generic Eve ARPG check");
 Console.WriteLine("Verse replica authority: remote client targets resolve to cache-only replica .cc files fed from the daemon");
 Console.WriteLine("Verse settings shell: client target edits and Verse-host visibility commands lower through typed Eve surfaces");
 Console.WriteLine("Main-menu Verse document access: the Unity Eve shell composes daemon-owned verse identity from typed documents instead of ad-libbing local menu copy");
@@ -10038,6 +10040,77 @@ static void RequireClientTargetBootAuthority(string root)
     }
 }
 
+static void RequireClientRuntimeConformanceContract(string root)
+{
+    var conformancePath = Path.Combine(root, "Aetheria.State", "docs", "client-runtime-conformance.md");
+    var authorityPlanPath = Path.Combine(root, "Aetheria.State", "docs", "verse-authority-implementation-plan.md");
+    var ergonomicsPlanPath = Path.Combine(root, "Aetheria.State", "docs", "cultmesh-ergonomics-staged-migration-plan.md");
+
+    var conformance = File.Exists(conformancePath)
+        ? File.ReadAllText(conformancePath)
+        : throw new InvalidOperationException("Client runtime conformance contract is missing.");
+    var authorityPlan = File.Exists(authorityPlanPath)
+        ? File.ReadAllText(authorityPlanPath)
+        : throw new InvalidOperationException("Verse authority implementation plan is missing.");
+    var ergonomicsPlan = File.Exists(ergonomicsPlanPath)
+        ? File.ReadAllText(ergonomicsPlanPath)
+        : throw new InvalidOperationException("CultMesh ergonomics staged migration plan is missing.");
+
+    var requiredContractSymbols = new[]
+    {
+        "Hermodr | Unspecialized Eve/browser lowering sanity check for the RTS surface.",
+        "Electron | Player-facing Starbridge RTS client.",
+        "Unity | Current ARPG reference client and demolition target.",
+        "Godot | Future unspecialized Eve/runtime parity target for the ARPG surface.",
+        "No daemon-side `Godot` mode, `Electron` mode, `Hermodr` mode, or `Unity`",
+        "No Aetheria-specific Hermodr plugin for RTS map semantics.",
+        "Godot lowers the ARPG contract without inheriting Unity authority."
+    };
+    var missingContractSymbols = requiredContractSymbols
+        .Where(symbol => !conformance.Contains(symbol, StringComparison.Ordinal))
+        .ToArray();
+    if (missingContractSymbols.Length > 0)
+    {
+        throw new InvalidOperationException(
+            "Client runtime conformance contract no longer names the runtime authority map: " +
+            string.Join(", ", missingContractSymbols));
+    }
+
+    var requiredPlanSymbols = new[]
+    {
+        "Hermodr is the unspecialized Eve sanity check for the RTS surface",
+        "player-facing RTS client",
+        "future unspecialized Eve parity target for the ARPG surface",
+        "Hermodr must be able to reconstruct the RTS surface from Eve plus daemon API",
+        "Any daemon-side `Godot` behavior branch would be the wrong cut"
+    };
+    var missingPlanSymbols = requiredPlanSymbols
+        .Where(symbol => !authorityPlan.Contains(symbol, StringComparison.Ordinal))
+        .ToArray();
+    if (missingPlanSymbols.Length > 0)
+    {
+        throw new InvalidOperationException(
+            "Verse authority plan no longer preserves Hermodr/Electron/Godot/Unity conformance roles: " +
+            string.Join(", ", missingPlanSymbols));
+    }
+
+    var requiredErgonomicsSymbols = new[]
+    {
+        "Hermodr can reconstruct the RTS gameplay surface as an unspecialized Eve",
+        "Electron may be the shipped RTS shell but cannot own private",
+        "Godot can become the ARPG equivalent conformance target"
+    };
+    var missingErgonomicsSymbols = requiredErgonomicsSymbols
+        .Where(symbol => !ergonomicsPlan.Contains(symbol, StringComparison.Ordinal))
+        .ToArray();
+    if (missingErgonomicsSymbols.Length > 0)
+    {
+        throw new InvalidOperationException(
+            "CultMesh ergonomics plan no longer carries the client runtime conformance gate: " +
+            string.Join(", ", missingErgonomicsSymbols));
+    }
+}
+
 static void RequireVerseReplicaTool(string root)
 {
     var replicaToolProjectPath = Path.Combine(root, "Aetheria.State.Replica", "Aetheria.State.Replica.csproj");

Aetheria.State/docs/client-runtime-conformance.md

@@ -0,0 +1,56 @@
+# Aetheria Client Runtime Conformance
+
+This is the client-runtime authority map for removing Unity as a privileged
+gameplay body without replacing it with a new privileged runtime.
+
+The daemon owns Aetheria game state, simulation, generated level content,
+assets, render-field declarations, Eve/CultUI surfaces, and typed operations.
+Client runtimes lower those surfaces and submit typed operations. A runtime may
+own presentation, input hardware, local caches, native buffers, and frame
+timing. It must not own gameplay truth merely because it can draw the game.
+
+## Runtime Roles
+
+| Runtime | Role | Pass condition |
+| --- | --- | --- |
+| Hermodr | Unspecialized Eve/browser lowering sanity check for the RTS surface. | It reconstructs the Aetheria RTS gameplay surface from daemon-advertised Eve surfaces, typed state pointers, typed operations, render-field declarations, and CultMesh CDN assets without Aetheria-specific renderer code. |
+| Electron | Player-facing Starbridge RTS client. | It renders the same daemon-authored RTS surface through the shared Eve package, with only app shell, launch, packaging, and runtime ergonomics outside Eve. |
+| Unity | Current ARPG reference client and demolition target. | It behaves as a renderer/input shell over daemon state and Eve/CultUI surfaces; remaining GameObject, UI Toolkit, camera, input, and presentation adapters are classified shims or renderer-owned concerns. |
+| Godot | Future unspecialized Eve/runtime parity target for the ARPG surface. | It reconstructs the ARPG gameplay surface from daemon API plus Eve/CultUI/render-field specs and CultMesh CDN assets, not from a Unity port or daemon-side Godot mode. |
+
+Hermodr is the purity test for the RTS surface. Electron is the shipped RTS
+client. Those are different jobs. If Electron can display something Hermodr
+cannot reconstruct from Eve plus daemon API, either Electron is using a private
+shortcut or Eve/CultMesh is missing a reusable primitive.
+
+Godot has the same relationship to the ARPG surface that Hermodr has to the RTS
+surface. It should prove the ARPG client can be rebuilt from generic Eve,
+CultMesh state, daemon-owned assets, and engine-native lowering. It should not
+inherit Unity scene authority, Unity coordinate leakage, Unity UI Toolkit
+assumptions, or Unity-only gameplay adapters.
+
+## Forbidden Shapes
+
+- No daemon-side `Godot` mode, `Electron` mode, `Hermodr` mode, or `Unity`
+  behavior branch for gameplay state.
+- No renderer-local Aetheria compensator that changes game behavior instead of
+  being promoted into Eve/CultMesh or daemon-authored state.
+- No Aetheria-specific Hermodr plugin for RTS map semantics.
+- No Godot port of Unity scene code as the ARPG authority.
+- No Electron-only field, asset, or command interpretation that Hermodr cannot
+  consume through shared Eve/CultMesh primitives.
+
+## Acceptance Gates
+
+1. The daemon publishes the RTS surface as Eve/CultUI plus typed state pointers,
+   operation handles, render-field declarations, and CultMesh CDN asset refs.
+2. Hermodr lowers that RTS surface without Aetheria-specific renderer code.
+3. Electron renders the same RTS surface through the shared Eve package.
+4. The daemon publishes the ARPG surface with the same kind of portable surface
+   contract.
+5. Unity consumes the ARPG contract as a renderer/input shell, with remaining
+   shims listed for deletion.
+6. Godot lowers the ARPG contract without inheriting Unity authority.
+
+Until those gates pass, Aetheria is daemon-authoritative in pieces, not free of
+Unity as a complete client dependency.

Aetheria.State/docs/cultmesh-ergonomics-staged-migration-plan.md

@@ -586,6 +586,13 @@ The migration is MVP-complete when:
 - Eve/CultUI surfaces use typed state pointers and typed operation handles.
 - Aetheria exposes current stats, inventory, equipment, selection, objects viewport, gravity viewport, and authority-aware operations as typed surfaces.
 - Unity and browser clients can point at the same Verse and observe/interact with the same simulation according to authority policy.
+- Hermodr can reconstruct the RTS gameplay surface as an unspecialized Eve
+  lowering from daemon API, Eve/CultUI, render-field declarations, and CultMesh
+  CDN assets; Electron may be the shipped RTS shell but cannot own private
+  gameplay interpretation.
+- Godot can become the ARPG equivalent conformance target by lowering the
+  daemon-authored ARPG Eve/CultUI contract, not by inheriting Unity scene
+  authority or triggering daemon-side runtime branches.
 - Co-located clients can use native slab views where available.
 - Remote clients use the same facade shape over network routes.
 - Locality is visible in diagnostics, not application logic.

Aetheria.State/docs/verse-authority-implementation-plan.md

@@ -590,15 +590,23 @@ Notes:
 
 Status: active. Stage 7A through 7C are implemented for the Electron proving
 surface; Stage 7D.4 is the current gate after the initial shared C# facade and
-typed Unity command reroute.
+typed Unity command reroute. The client-runtime conformance contract in
+`Aetheria.State/docs/client-runtime-conformance.md` is now the live role map:
+Hermodr is the unspecialized Eve sanity check for the RTS surface. Electron is
+the player-facing RTS client. Unity is the current ARPG reference shell. Godot
+is the future unspecialized Eve parity target for the ARPG surface.
 
-Owner: Unity and Electron runtime clients.
+Owner: daemon-authored client surfaces, with Unity and Electron as current
+product runtimes and Hermodr/Godot as generic Eve conformance targets.
 
 Build:
 
 Stage 7 is the client parity stage. It is not an RTS feature pass. Its job is
 to make Unity and Electron use the same local Verse shape before any more
-gameplay is added.
+gameplay is added, while keeping the generic conformance question explicit:
+Hermodr must be able to reconstruct the RTS surface from Eve plus daemon API
+without Aetheria-specific lowering, and Godot must eventually do the same for
+the ARPG surface.
 
 Implementation slices:
 
@@ -638,6 +646,29 @@ Implementation slices:
    - neither runtime reads a peer viewport as authoritative gameplay.
 7. Only after the parity smoke passes, begin Stage 8 Unity shell demolition.
 
+Hermodr/Electron distinction:
+
+- Hermodr is a browser/Eve lowering sanity check. It should discover Aetheria
+  through Odin/CultMesh, fetch daemon-owned surfaces/state/assets, and lower the
+  RTS gameplay surface without Aetheria-specific map or command code.
+- Electron is the Starbridge RTS application shell. It may own launch,
+  packaging, player-facing ergonomics, and runtime app concerns, but the surface
+  it renders must be the same Eve/CultMesh contract Hermodr can lower.
+- If Electron displays or commands gameplay through a path Hermodr cannot
+  reconstruct from Eve plus daemon API, the private path is architectural debt.
+
+Unity/Godot distinction:
+
+- Unity remains the current ARPG reference and demolition target. It may keep
+  presentation, input, camera, GameObject, and UI Toolkit adapters only while
+  they lower daemon-authored state and surfaces.
+- Godot is not a Unity port target. It is the ARPG equivalent of the Hermodr
+  check: a new runtime should reconstruct the ARPG surface from Eve/CultUI,
+  typed state, typed operations, render-field specs, and CultMesh CDN assets.
+- Any daemon-side `Godot` behavior branch would be the wrong cut. If Godot needs
+  a special gameplay hint, that hint belongs in daemon-authored Eve/CultMesh
+  surface state or a reusable Eve/CultMesh primitive.
+
 Shared runtime configuration:
 
 - verse id;