fix: pre-inject core service fallbacks before Phase 2 so ctx.getService('metadata') succeeds during plugin starts

Agent-Logs-Url: https://github.com/objectstack-ai/framework/sessions/f9c31840-b5a5-498e-85f1-f42b38e65983

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Copilot

CHANGELOG.md

@@ -72,12 +72,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 - **AI Chat agent selector missing `data_chat` and `metadata_assistant`** — Fixed `GET /api/v1/ai/agents`
-  returning 404, which caused the Studio AI Chat panel to show only "General Chat". Root cause was a
-  redundant second `ctx.getService('metadata')` call inside `AIServicePlugin.start()` that shadowed
-  the outer resolved variable and failed silently, preventing `buildAgentRoutes()` from being called.
-  Fix: reuse the already-resolved `metadataService` variable instead of re-fetching it. Additionally,
-  added a fallback in `DispatcherPlugin.start()` that recovers AI routes from the `kernel.__aiRoutes`
-  cache in case the `ai:routes` hook fires before the listener is registered (timing edge case).
+  returning 404, which caused the Studio AI Chat panel to show only "General Chat". There were two
+  root causes addressed by this fix:
+  1. **Kernel bootstrap timing** (`packages/core/src/kernel.ts`): 'core' service in-memory fallbacks
+     (e.g. the 'metadata' service) were only injected in `validateSystemRequirements()` which runs
+     AFTER all plugin `start()` methods execute. This meant `ctx.getService('metadata')` always threw
+     during `AIServicePlugin.start()` when no explicit `MetadataPlugin` was loaded. Fix: added
+     `preInjectCoreFallbacks()` called between Phase 1 (init) and Phase 2 (start), ensuring all core
+     service fallbacks are available before any plugin's `start()` runs.
+  2. **Shadowed variable** (`packages/services/service-ai/src/plugin.ts`): a redundant second
+     `ctx.getService('metadata')` call declared a new `const metadataService` that shadowed the outer
+     `let metadataService` and failed silently, preventing `buildAgentRoutes()` from being called even
+     if the metadata service was available. Fix: reuse the already-resolved outer variable.
+  Additionally, added a fallback in `DispatcherPlugin.start()` that recovers AI routes from the
+  `kernel.__aiRoutes` cache in case the `ai:routes` hook fires before the listener is registered
+  (timing edge case).
 - **ObjectQLPlugin: cold-start metadata restoration** — `ObjectQLPlugin.start()` now calls
   `protocol.loadMetaFromDb()` after driver initialization and before schema sync, restoring
   all persisted metadata (objects, views, apps, etc.) from the `sys_metadata` table into the

packages/core/src/kernel.ts

@@ -213,6 +213,28 @@ export class ObjectKernel {
         return this;
     }
 
+    /**
+     * Pre-inject in-memory fallbacks for 'core' services that were not registered
+     * by plugins during Phase 1. Called before Phase 2 so that all core services
+     * (e.g. 'metadata', 'cache', 'queue') are resolvable via ctx.getService()
+     * when plugin start() methods execute.
+     */
+    private preInjectCoreFallbacks() {
+        if (this.config.skipSystemValidation) return;
+        for (const [serviceName, criticality] of Object.entries(ServiceRequirementDef)) {
+            if (criticality !== 'core') continue;
+            const hasService = this.services.has(serviceName) || this.pluginLoader.hasService(serviceName);
+            if (!hasService) {
+                const factory = CORE_FALLBACK_FACTORIES[serviceName];
+                if (factory) {
+                    const fallback = factory();
+                    this.registerService(serviceName, fallback);
+                    this.logger.debug(`[Kernel] Pre-injected in-memory fallback for '${serviceName}' before Phase 2`);
+                }
+            }
+        }
+    }
+
     /**
      * Validate Critical System Requirements
      */
@@ -291,6 +313,12 @@ export class ObjectKernel {
                 await this.initPluginWithTimeout(plugin);
             }
 
+            // Pre-inject in-memory fallbacks for 'core' services that were not
+            // registered by any plugin during Phase 1. This ensures services like
+            // 'metadata', 'cache', 'queue', etc. are always available when plugins
+            // call ctx.getService() during their start() methods.
+            this.preInjectCoreFallbacks();
+
             // Phase 2: Start - Plugins execute business logic
             this.logger.info('Phase 2: Start plugins');
             this.state = 'running';