fix(runtime): stop reporting inert workers as ready

Author: erwinmsmith

apps/server/src/app.ts

@@ -339,19 +339,31 @@ class Application {
       logger.error('  Memory      | Error:', safeError);
     }
 
-    // 4. Check canonical Runtime Event authority.
+    // 4. Check both the canonical Event authority and the executable Runtime.
+    // Event-store health alone must never be reported as continuous execution
+    // readiness when the graph or durable workers have not been started.
     try {
       const runtimeHealth = await this.canonicalRuntime?.get().backbone.eventStore.health();
-      const healthy = runtimeHealth?.status === 'healthy';
+      const execution = this.canonicalRuntime?.executionReadiness();
+      const eventStoreHealthy = runtimeHealth?.status === 'healthy';
+      const healthy = eventStoreHealthy && execution?.ready === true;
       checks.push({
         name: 'Runtime',
         status: healthy ? 'pass' : 'fail',
-        detail: runtimeHealth?.message ?? runtimeHealth?.status ?? 'not initialized',
+        detail: !eventStoreHealthy
+          ? (runtimeHealth?.message ?? runtimeHealth?.status ?? 'Event authority not initialized')
+          : (execution?.message ?? 'Runtime execution state is unavailable'),
       });
       if (healthy) {
-        logger.info('  ✅ Runtime     │ Canonical Event store ready');
+        logger.info('  ✅ Runtime     │ Canonical execution workers ready');
       } else {
-        logger.error('  ❌ Runtime     │ Canonical Event store unavailable');
+        logger.error(
+          `  ❌ Runtime     │ ${
+            !eventStoreHealthy
+              ? 'Canonical Event store unavailable'
+              : (execution?.message ?? 'Execution state unavailable')
+          }`
+        );
       }
     } catch (err) {
       checks.push({ name: 'Runtime', status: 'fail', detail: String(err) });

apps/server/src/runtime/ServerCanonicalRuntime.test.ts

@@ -107,11 +107,24 @@ describe('ServerCanonicalRuntime', () => {
     const service = createService(new InMemoryEventStore());
     const bindings = executionBindings();
 
+    expect(service.executionReadiness()).toMatchObject({
+      ready: false,
+      state: 'not_initialized',
+    });
     expect(() => service.composeRuntime(bindings)).toThrow('Canonical Runtime is not initialized');
 
     const canonical = await service.initialize();
+    expect(service.executionReadiness()).toMatchObject({
+      ready: false,
+      state: 'event_authority_ready',
+    });
     const runtime = service.composeRuntime(bindings);
 
+    expect(service.executionReadiness()).toMatchObject({
+      ready: false,
+      state: 'execution_graph_ready',
+    });
+
     expect(runtime.events).toBe(canonical.backbone.events);
     expect(runtime.projections).toBe(canonical.backbone.projections);
     expect(runtime.projectionStore).toBe(canonical.backbone.projectionStore);
@@ -137,6 +150,11 @@ describe('ServerCanonicalRuntime', () => {
 
     expect(first).toBe(second);
     expect(service.areWorkersRunning()).toBe(true);
+    expect(service.executionReadiness()).toEqual({
+      ready: true,
+      state: 'workers_running',
+      message: 'Canonical Runtime execution graph and durable workers are running',
+    });
 
     const firstClose = service.close();
     const secondClose = service.close();
@@ -146,6 +164,7 @@ describe('ServerCanonicalRuntime', () => {
     expect(first.timer.isRunning()).toBe(false);
     expect(first.recovery.isRunning()).toBe(false);
     expect(service.areWorkersRunning()).toBe(false);
+    expect(service.executionReadiness()).toMatchObject({ ready: false, state: 'closed' });
     expect(() => service.composeRuntime(executionBindings())).toThrow(
       'Canonical Runtime is closed'
     );

apps/server/src/runtime/ServerCanonicalRuntime.ts

@@ -50,6 +50,19 @@ export interface ServerCanonicalRuntimeComposition {
   migration: CanonicalEventFamilyMigrationReport;
 }
 
+export type ServerRuntimeExecutionState =
+  | 'not_initialized'
+  | 'event_authority_ready'
+  | 'execution_graph_ready'
+  | 'workers_running'
+  | 'closed';
+
+export interface ServerRuntimeExecutionReadiness {
+  ready: boolean;
+  state: ServerRuntimeExecutionState;
+  message: string;
+}
+
 /**
  * Owns the Server cutover from compatibility Events to the canonical Runtime
  * store. Migration and bounded replay complete before the merged EventStore is
@@ -222,6 +235,47 @@ export class ServerCanonicalRuntime {
     return this.workerLifecycle?.isRunning() ?? false;
   }
 
+  /**
+   * Reports product execution readiness separately from Event-store health.
+   * A healthy Event authority is necessary, but it does not prove that the
+   * execution graph or any durable worker loop is active.
+   */
+  executionReadiness(): Readonly<ServerRuntimeExecutionReadiness> {
+    if (this.closed) {
+      return Object.freeze({
+        ready: false,
+        state: 'closed',
+        message: 'Canonical Runtime is closed',
+      });
+    }
+    if (!this.composition) {
+      return Object.freeze({
+        ready: false,
+        state: 'not_initialized',
+        message: 'Canonical Runtime Event authority is not initialized',
+      });
+    }
+    if (!this.runtimeComposition) {
+      return Object.freeze({
+        ready: false,
+        state: 'event_authority_ready',
+        message: 'Canonical Runtime execution graph is not composed',
+      });
+    }
+    if (!this.areWorkersRunning()) {
+      return Object.freeze({
+        ready: false,
+        state: 'execution_graph_ready',
+        message: 'Canonical Runtime durable workers are not running',
+      });
+    }
+    return Object.freeze({
+      ready: true,
+      state: 'workers_running',
+      message: 'Canonical Runtime execution graph and durable workers are running',
+    });
+  }
+
   isInitialized(): boolean {
     return !this.closed && this.composition !== undefined;
   }