Preserve live engine status across delayed startup snapshots

Ignore per-engine hydration results when a newer state notification arrived while the request was in flight. This prevents an already-running engine from displaying Start and then stopping when toggled.

Cover both running and stopped updates for llama.cpp, Ollama, and LM Studio, plus a later uncontested refresh. Native UI reproduction retained privately; fixed-build UI retest remains pending.

Signed-off-by: pgoode41 <pgoode41@gmail.com>

Author: pgoode41

desktop/src/electron/service-bridge/modular-supervisor.ts

@@ -335,6 +335,7 @@ function proxyEngineFromRelaySource(source: string): ProxyEngine | null {
  */
 class ModularSupervisor {
     private processes = new Map<ModularProcessName, JsonRpcSubprocess>()
+    private engineEventRevisions = new Map<EngineType, number>()
     private readinessWaiters = new Map<number, ReadinessWaiter>()
     private nextReadinessWaiterId = 0
     private readinessReported = false
@@ -1126,10 +1127,14 @@ class ModularSupervisor {
     private async hydrateEngineManager(): Promise<void> {
         if (!this.processes.has('broker')) return
         try {
+            // A push received while this snapshot is in flight wins for its engine.
+            const atStart = new Map(this.engineEventRevisions)
             const result = await this.callProcess('broker', 'engine:get-installed')
             const obj = objectValue(result)
             if (!obj || !Array.isArray(obj.engines)) return
             for (const engine of obj.engines) {
+                const type = engineTypeFromManagerName(stringValue(objectValue(engine)?.engine))
+                if (!type || this.engineEventRevisions.get(type) !== atStart.get(type)) continue
                 getModularBridgeState().applyEngineManagerStatus(engine)
                 this.refreshManagedEngineModels(engine)
             }
@@ -1637,6 +1642,12 @@ class ModularSupervisor {
             return
         }
         if (notification.method === 'engine:state-changed') {
+            const type = engineTypeFromManagerName(
+                stringValue(objectValue(notification.params)?.engine)
+            )
+            if (type) {
+                this.engineEventRevisions.set(type, (this.engineEventRevisions.get(type) ?? 0) + 1)
+            }
             getModularBridgeState().applyEngineManagerStatus(notification.params)
             this.refreshManagedEngineModels(notification.params)
             this.updateLocalNodeBridgeFromEngineState(notification.params)

desktop/tests/modular/modular-supervisor-readiness.test.ts

@@ -10,6 +10,8 @@ import {
 const mocks = vi.hoisted(() => ({
     bridgeState: {
         handleNotification: vi.fn(),
+        applyEngineManagerStatus: vi.fn(),
+        modelPullTarget: vi.fn(() => null),
         getSelfId: vi.fn(() => null),
         getProxyPort: vi.fn(() => null)
     },
@@ -51,6 +53,7 @@ vi.mock('@/electron/service-bridge/node-info-poller', () => ({
 
 vi.mock('@/electron/service-bridge/modular-state', () => ({
     getModularBridgeState: () => mocks.bridgeState,
+    isProxyEngine: () => false,
     isUpstreamUnreachableError: () => false,
     parseServiceErrors: () => [],
     parseWorkloadsInitial: () => [],
@@ -66,6 +69,10 @@ import {
 interface ReadinessHarness {
     readonly ready: boolean
     processes: Map<string, JsonRpcSubprocess>
+    engineEventRevisions: Map<string, number>
+    hydrateEngineManager: () => Promise<void>
+    handleEngineManagerNotification: (notification: JsonRpcNotification) => void
+    callProcess: (process: string, method: string) => Promise<unknown>
     isReady: boolean
     brokerReady: boolean
     brokerHydrationDone: boolean
@@ -99,11 +106,14 @@ describe('modular supervisor readiness', () => {
         supervisor.brokerReady = false
         supervisor.brokerHydrationDone = false
         supervisor.processes.clear()
+        supervisor.engineEventRevisions.clear()
+        mocks.bridgeState.applyEngineManagerStatus.mockClear()
         supervisor.onReady = undefined
         supervisor.onBrokerReady = vi.fn().mockResolvedValue(undefined)
     })
 
     afterEach(() => {
+        vi.restoreAllMocks()
         for (const waiter of supervisor.readinessWaiters.values()) {
             clearTimeout(waiter.timeout)
         }
@@ -194,4 +204,37 @@ describe('modular supervisor readiness', () => {
 
         expect(supervisor.ready).toBe(true)
     })
+
+    it.each(['llamacpp', 'ollama', 'lmstudio'])(
+        'keeps newer %s pushes when the initial engine snapshot arrives late',
+        async engine => {
+            supervisor.processes.set('broker', new JsonRpcSubprocess('broker', 'unused'))
+            for (const running of [true, false]) {
+                let resolve!: (value: unknown) => void
+                vi.spyOn(supervisor, 'callProcess').mockImplementation(
+                    () =>
+                        new Promise(value => {
+                            resolve = value
+                        })
+                )
+                const pending = supervisor.hydrateEngineManager()
+                const newer = { engine, installed: true, running, healthy: running }
+                supervisor.handleEngineManagerNotification({
+                    source: 'broker',
+                    method: 'engine:state-changed',
+                    params: newer
+                })
+                resolve({ engines: [{ ...newer, running: !running }] })
+                await pending
+                expect(mocks.bridgeState.applyEngineManagerStatus).toHaveBeenLastCalledWith(newer)
+                mocks.bridgeState.applyEngineManagerStatus.mockClear()
+
+                const fresh = { ...newer, running: !running }
+                vi.spyOn(supervisor, 'callProcess').mockResolvedValue({ engines: [fresh] })
+                await supervisor.hydrateEngineManager()
+                expect(mocks.bridgeState.applyEngineManagerStatus).toHaveBeenCalledWith(fresh)
+                vi.restoreAllMocks()
+            }
+        }
+    )
 })