From 9fbc77e4e998cd9f139d028bfb7e8f24627b96ef Mon Sep 17 00:00:00 2001
From: Meta Vens <rwvens@hotmail.com>
Date: Sat, 13 Jun 2026 15:47:57 +0100
Subject: [PATCH] Drain runtime commits from Economy server

---
 .voidbot/state/aetheria.cc           | Bin 36132 -> 36575 bytes
 Aetheria.State/README.md             |  12 +++++-
 Economy.Server/Program.cs            |  58 +++++++++++++++++++++++++--
 docs/aetheria-perfect-machine-map.md |  15 +++++--
 4 files changed, 76 insertions(+), 9 deletions(-)

diff --git a/.voidbot/state/aetheria.cc b/.voidbot/state/aetheria.cc
index 54ef3c3f498e2126a6eb041beabc8ea7853042e7..0473a60bc25847453b755fe92919f6a2aff6ccd9 100644
GIT binary patch
delta 1449
zcmZWpQEOa96t<fZ8(UJOvIS}MNWngsy-B((iB$_VmQZW8rU9`O%j~^p_f9)^W->E3
zn^oxA6a-&Hn75)J8Yzf~vM<)R`YH&eAcPkB4+QbaH_zOAH#7+>%f08$ob!F(`OewA
zU3>g>?dLnS1M{cmn$i5ioS(aS%>PmQtO~q(k^*(F#y%MZT1DW%{;ArH&Ebjt>5E6)
z*;q-H^`lE@*3f`dJ^$c%bI?n<KuDE!Tz0{w2xpM~4QH^J3wHr+3f3`)bR)s&`&clZ
zZT))@WfCr!Tsod1#45|U1E#g$F>_o=;Fhj{P_j$qloWknkTIDv0gLaPgSO#G7Y7mS
z0#>9z3%aUMX10_e;4m)N)1Z|Q7CMS(U~kXKk`f`4gm4;|Ou*(^E8{FQ8X<qbQDtuo
zl#H>+)K<AnFaZ*WcPb7uN~2+p>QFWt-Ek-_QQP`_g>*^`<C6F(9jG#Tiiuh$$Qkev
z={8!PU?FNLVfZ*rsyOH)i3Oc}AV`go&Vg!)wryj>bs-}aKf8vFHEwyEQd?>tC&)H8
z9TsEs3yZ_CbJ@1=Ti?Em>#jJ6h8S4rDRUics&bJ4u4`pWOo70lWN^YlicGk48U(Yh
z5Q&o*F^S@Aso|(032K)Dv*7xgj*QUH5X#CaTv~@L0o4J6q91%h-6Q{5MGS=M+UN%+
z<5ZdDaqQSfPpu3;e);~PeW(04H|objTLVip4b_uWVY~3Q;KQ$)hmO4c=36SxGbDg}
zJVfBAL)!3+nf`Wy%A{rEg5{%I-x=&|&G;{)mxhOz{ysQf1n&BW&%EG&Tb@im7_qCE
zg-c;{N~1sF(w%egq+1LBB@DAL64DVdCZZp4jhsQ&TQ2y|`^o0)@Qq8i4_;Zh$gIWW
zwcV3Nsu2cGc3I6a$Iz27YsCW@JQm1|CEZ+@V>?55z)Gg6>&{j*-}8^Jo*%AXJ@cIZ
zbG1ITbMCI}eD&|^WBv=XxUWr@j-KE7ao5=>w%Vv`G+Xp5jsCjBOrPE}ZDH8_y^rck
zOCy#vV4=kf!i7p?qi8_F98kZsKu6z|q;6IVp=@8=C(8a;d-~aODYjadHy!JenJ)O%
zPwT@e_h{_!PgpL!M(L;Ff4#|xYDKnM{^rK><;%isllJ9bqnCwhn~wWeHgpx7D_88@
bjg6;^dbET889O@s@Ye4W6J_A!?B)LfMo<+^

delta 1096
zcmZvc%WD)t5XQ}J$OD7;h%P8%K~NErUGrE?6oMg95Mszfa>&K>&XhAvX1gc-*svl-
zj2;9JhVdkLkw`$41jf4}c=4pifS^~8`WIL;I~xOf+M&9t`ul!Wz29HtHlF9UH*=lm
zFO~a?BmEZ_)?1E7pK?#Kz`#%%__5X&*}QEA8(AH#Cv$gy#%EjoQ-`09q4801212fY
z&oo5a>O`Rz7$^*7UmzV8!1&~KFg`QU%bvj=<11-BADWeOh8diaE*4)o0pr!3_tVkV
z?6Fnq2!RwHDr&WCxk6wr_|gGgl}lJMs0}z&2S!2#9a%+in2>@eSL&o|5pMdJ-p(~C
zsz@tbbU}uwnBh`TUPW=&L$Jc|fHWewig7^~ugVap%9q+u2^nMHGOS8b8n=PDf!c=^
zsg_U`Hw_9+-FDvYxlL2Q0IEz_7L-y74Kbl5ABHIpP12q)Ss}RaU>=o5kji5sWwqE)
zq9H`#CJAJa+PRu?fH@9^MkmFFC%$*jYJ}^rKyG|#O=g(txG<<{NJUaa>!-V;`|WLH
zG{d36p=3=Zft#7-cM?sYsfs(;m(WNlHAS&742ZW$Gzk|%TM0Ok;iSz+78t+eu#i=F
zzzs)DrH$D)6_&2nZ~|x;v_pw&0*|b=$87^b5=bY|;F(Oc_?ijFmuePo>u>w!;`uXQ
zyJlv_EE!hZ)QNmZYvV{oz>=}<6-wB}f0m$^HqOvQ($xXEB2dL_u<OX^=!A4^m8kvG
zD&wAd&%XPl2<p3o38WWqT`P1Qe1kRaqHwSwxEwFeeclgK(@bl0FGHwgjreFZhRh}c
z-K0m<GFvDtTeL_oicr_-hfW-#q~d$Go^?l89(PA|d+t#Bj)zCe3mb-cL}W6K?eBd2
zu704iqj?s6$sf<2^5BK^edpFbWPzc9?7`RC8-EEy(XV_VG7ld#6NZz7xckw^&MZ<M
GSoi}Z$%pa)

diff --git a/Aetheria.State/README.md b/Aetheria.State/README.md
index 1f34b5abb..247d3908a 100644
--- a/Aetheria.State/README.md
+++ b/Aetheria.State/README.md
@@ -129,8 +129,16 @@ catalog reader. It also proves runtime commit envelopes for settings and run
 zone/entity snapshots can be queued, applied through `Aetheria.State`, and
 cleared.
 
-`Aetheria.State.ApplyPending` is the bounded local applicator for queued Unity
-runtime commits:
+`Economy.Server` opens the CultMesh state host, applies pending runtime commits
+on startup, and polls for new pending commits while running. For a bounded
+one-shot drain without leaving the host running:
+
+```powershell
+dotnet run --project .\Economy.Server\Economy.Server.csproj -- --apply-pending-once
+```
+
+`Aetheria.State.ApplyPending` is the smaller local operator applicator for
+queued Unity runtime commits when the server host is not being used:
 
 ```powershell
 dotnet run --project .\Aetheria.State.ApplyPending\Aetheria.State.ApplyPending.csproj -- .
diff --git a/Economy.Server/Program.cs b/Economy.Server/Program.cs
index e653b7e46..bacd10b21 100644
--- a/Economy.Server/Program.cs
+++ b/Economy.Server/Program.cs
@@ -16,10 +16,17 @@ internal static class Program
             startServer: true).ConfigureAwait(false);
 
         await EnsureWorldDocumentAsync(node).ConfigureAwait(false);
+        await ApplyPendingRuntimeCommitsAsync(node).ConfigureAwait(false);
         await node.FlushAsync().ConfigureAwait(false);
 
+        if (HasFlag(args, "--apply-pending-once"))
+        {
+            Console.WriteLine("Aetheria pending runtime commit drain completed.");
+            return;
+        }
+
         Console.WriteLine("Aetheria CultMesh state host is running. Press Ctrl+C to stop.");
-        await WaitForShutdownAsync().ConfigureAwait(false);
+        await RunUntilShutdownAsync(node, PendingInterval(args)).ConfigureAwait(false);
 
         Console.WriteLine("Aetheria CultMesh state host stopping.");
     }
@@ -59,7 +66,24 @@ internal static class Program
         }).ConfigureAwait(false);
     }
 
-    private static Task WaitForShutdownAsync()
+    private static async Task ApplyPendingRuntimeCommitsAsync(AetheriaStateNode node)
+    {
+        var report = await AetheriaRuntimeCommitLogApplier.ApplyPendingAsync(node).ConfigureAwait(false);
+        if (report.AppliedPaths.Length == 0)
+        {
+            Console.WriteLine("No pending Aetheria runtime commits.");
+            return;
+        }
+
+        Console.WriteLine(
+            "Applied pending Aetheria runtime commits: " +
+            $"settings={report.AppliedPlayerSettings}, " +
+            $"loadouts={report.AppliedLoadoutTemplates}, " +
+            $"runs={report.AppliedRunCheckpoints}, " +
+            $"files={report.AppliedPaths.Length}");
+    }
+
+    private static async Task RunUntilShutdownAsync(AetheriaStateNode node, TimeSpan pendingInterval)
     {
         var stopped = new TaskCompletionSource<object?>();
         Console.CancelKeyPress += (_, eventArgs) =>
@@ -68,6 +92,34 @@ internal static class Program
             stopped.TrySetResult(null);
         };
 
-        return stopped.Task;
+        while (!stopped.Task.IsCompleted)
+        {
+            var delay = Task.Delay(pendingInterval);
+            var completed = await Task.WhenAny(stopped.Task, delay).ConfigureAwait(false);
+            if (completed == stopped.Task)
+                break;
+
+            await ApplyPendingRuntimeCommitsAsync(node).ConfigureAwait(false);
+        }
+    }
+
+    private static TimeSpan PendingInterval(IReadOnlyList<string> args)
+    {
+        for (var i = 0; i < args.Count - 1; i++)
+        {
+            if (string.Equals(args[i], "--pending-interval-ms", StringComparison.OrdinalIgnoreCase) &&
+                int.TryParse(args[i + 1], out var milliseconds) &&
+                milliseconds > 0)
+            {
+                return TimeSpan.FromMilliseconds(milliseconds);
+            }
+        }
+
+        return TimeSpan.FromSeconds(5);
+    }
+
+    private static bool HasFlag(IReadOnlyList<string> args, string flag)
+    {
+        return args.Any(arg => string.Equals(arg, flag, StringComparison.OrdinalIgnoreCase));
     }
 }
diff --git a/docs/aetheria-perfect-machine-map.md b/docs/aetheria-perfect-machine-map.md
index b8fb123f0..9f467826d 100644
--- a/docs/aetheria-perfect-machine-map.md
+++ b/docs/aetheria-perfect-machine-map.md
@@ -41,9 +41,10 @@ legacy catalog cache, and legacy UI paths should be migration-only or deleted.
   files, and generated keyboard layout caches no longer write bespoke durable files. The
   legacy
   `PlayerSettings` runtime object is no longer decorated as a MessagePack
-  persistence shape. `Aetheria.State.ApplyPending` is the repo-local applicator
-  entrypoint for draining `aetheria-world.cc.pending` into canonical typed state
-  until that worker is hosted as a daemon/CultMesh organ.
+  persistence shape. `Economy.Server` now drains `aetheria-world.cc.pending`
+  into canonical typed state on startup and on a daemon polling loop while
+  hosting the CultMesh state node. `Aetheria.State.ApplyPending` remains a
+  bounded local operator applicator.
 - Shared domain state is still partly built around `DatabaseEntry`, GUID
   identity, MessagePack attributes, and static cache references. Newtonsoft,
   JsonKnownTypes, RethinkDB, LiteNetLib client transport, and the broken
@@ -117,7 +118,8 @@ legacy catalog cache, and legacy UI paths should be migration-only or deleted.
   `ActionGameManager` binds the typed runtime item catalog projected from
   `aetheria-world.cc`. MessagePack catalog construction no longer grabs global
   `DatabaseLinkBase` authority.
-- `Economy.Server` now starts the modern `Aetheria.State` CultMesh node and no
+- `Economy.Server` now starts the modern `Aetheria.State` CultMesh node, drains
+  pending Unity runtime commits through the typed state applicator, and no
   longer owns RethinkDB/LiteNetLib state.
 - `Aetheria.State.Import` writes a typed quarantine manifest and migration
   ledger for the legacy catalog files. It also raw-decodes stable old
@@ -170,6 +172,9 @@ legacy catalog cache, and legacy UI paths should be migration-only or deleted.
   successfully applied command files by default. It is an operational bridge,
   not a second state owner; the applicator delegates all writes to
   `AetheriaStateNode`.
+- `Economy.Server` hosts the CultMesh state node and now owns the long-running
+  pending runtime commit drain loop. `--apply-pending-once` runs the same drain
+  path once for smoke/operator use without keeping the process alive.
 - `AetheriaCatalogSurfaceProjector` now emits the first provider-owned Eve
   surface from typed catalog state. The importer materializes a
   `gamecult.eve.surface.v1` catalog operator document at
@@ -530,6 +535,8 @@ First Aetheria surfaces to publish:
      documents.
    - Done: add `Aetheria.State.ApplyPending` as a bounded local applicator for
      queued runtime commits until the drain loop is hosted as a daemon.
+   - Done: move the pending runtime commit drain into `Economy.Server` startup
+     and daemon polling, with `--apply-pending-once` for bounded operation.
    - Done: stop legacy catalog pull/read paths from writing entries back to
      their source backing store.
    - Done: delete legacy catalog backing-store write/realtime APIs.