Feat: Add startup summarization status to healthcheck #7638

Author: tobiu

ai/mcp/server/memory-core/mcp-stdio.mjs

@@ -120,53 +120,60 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 /**
  * Proactively summarizes unsummarized sessions on startup.
  * Runs asynchronously to avoid blocking server startup.
- * 
+ * Records the result in HealthService so agents can see what happened.
+ *
  * @returns {Promise<void>}
  */
 async function summarizeSessionsOnStartup() {
     logger.info('[Startup] Checking for unsummarized sessions...');
-    
+
     try {
         const result = await SessionService.summarizeSessions({});
-        
+
         if (result.processed > 0) {
             logger.info(`✅ [Startup] Summarized ${result.processed} session(s):`);
             result.sessions.forEach(session => {
                 logger.info(`   - ${session.title} (${session.memoryCount} memories)`);
             });
+            HealthService.recordStartupSummarization('completed', {
+                processed: result.processed,
+                sessions : result.sessions.map(s => ({ title: s.title, memoryCount: s.memoryCount }))
+            });
         } else {
             logger.info('[Startup] No unsummarized sessions found');
+            HealthService.recordStartupSummarization('completed', { processed: 0 });
         }
     } catch (error) {
         logger.warn('⚠️  [Startup] Session summarization failed:', error.message);
         logger.warn('    You can manually trigger summarization using the summarize_sessions tool');
+        HealthService.recordStartupSummarization('failed', { error: error.message });
     }
 }
 
 /**
  * Main startup sequence for the Memory Core MCP server.
- * 
+ *
  * Performs the following steps:
- * 1. Health check - verifies ChromaDB connectivity
- * 2. Status reporting - logs detailed diagnostics
- * 3. Auto-summarization - processes unsummarized sessions (if healthy)
- * 4. Server startup - connects stdio transport
- * 
+ * 1. Wait for async services - ensures ChromaManager is initialized
+ * 2. Health check - verifies ChromaDB connectivity
+ * 3. Status reporting - logs detailed diagnostics
+ * 4. Auto-summarization - processes unsummarized sessions (if healthy)
+ * 5. Server startup - connects stdio transport
+ *
  * The server starts even if ChromaDB is unavailable, but tools will fail
  * gracefully with helpful error messages until dependencies are resolved.
  */
 async function main() {
-    // Wait for async services to initialize
+    // Wait for async services to initialize (fixes race condition)
     await ChromaManager.ready();
-
     // Perform initial health check (non-blocking)
     const health = await HealthService.healthcheck();
 
     // Report status based on health check results
     if (health.status === 'unhealthy') {
         logger.warn('⚠️  [Startup] Memory Core is unhealthy. Server will start but tools will fail until resolved.');
         health.details.forEach(detail => logger.warn(`    ${detail}`));
-        
+
         // Provide helpful guidance based on process status
         if (!health.database.process.running) {
             logger.warn('    💡 Tip: Use the start_database tool after server starts, or run:');
@@ -176,7 +183,7 @@ async function main() {
     } else if (health.status === 'degraded') {
         logger.warn('⚠️  [Startup] Memory Core is degraded. Some features may be unavailable.');
         health.details.forEach(detail => logger.warn(`    ${detail}`));
-        
+
         // Still proceed with summarization if ChromaDB is accessible, even without API key
         // This allows the user to see what would be summarized
         logger.info('✅ [Startup] ChromaDB connectivity confirmed');
@@ -191,7 +198,7 @@ async function main() {
             logger.info(`   - Memories: ${health.database.connection.collections.memories.count}`);
             logger.info(`   - Summaries: ${health.database.connection.collections.summaries.count}`);
         }
-        
+
         // Only auto-summarize if we're fully healthy
         if (health.features.summarization) {
             // Run summarization asynchronously (non-blocking)
@@ -201,6 +208,7 @@ async function main() {
         } else {
             logger.warn('⚠️  [Startup] GEMINI_API_KEY not set - skipping automatic session summarization');
             logger.warn('    Set GEMINI_API_KEY environment variable to enable summarization features');
+            HealthService.recordStartupSummarization('skipped', { reason: 'GEMINI_API_KEY not set' });
         }
     }
 

ai/mcp/server/memory-core/openapi.yaml

@@ -555,6 +555,26 @@ components:
               type: boolean
               description: "Indicates if the summarization feature is available (requires GEMINI_API_KEY)."
               example: true
+        startup:
+          type: object
+          description: "Provides status on asynchronous tasks performed at server startup."
+          properties:
+            summarizationStatus:
+              type: string
+              enum: [not_attempted, skipped, completed, failed]
+              description: "The status of the automatic session summarization attempt at startup."
+              example: "completed"
+            summarizationDetails:
+              type: object
+              nullable: true
+              description: "Details about the summarization result, present if status is 'completed' or 'failed'."
+              example:
+                processed: 2
+                sessions:
+                  - title: "Implement MCP Server Configuration"
+                    memoryCount: 15
+                  - title: "Debugged UI Rendering Issue"
+                    memoryCount: 25
         details:
           type: array
           items:

ai/mcp/server/memory-core/services/HealthService.mjs

@@ -71,6 +71,22 @@ class HealthService extends Base {
      */
     #previousStatus = null;
 
+    /**
+     * Tracks whether startup summarization has been attempted.
+     * This helps agents understand if they need to manually trigger summarization.
+     * Values: 'pending', 'completed', 'failed', 'skipped', null (if not yet attempted)
+     * @member {string|null} #startupSummarizationStatus
+     * @private
+     */
+    #startupSummarizationStatus = null;
+
+    /**
+     * Details about the startup summarization attempt
+     * @member {Object|null} #startupSummarizationDetails
+     * @private
+     */
+    #startupSummarizationDetails = null;
+
     /**
      * Checks if ChromaDB is running and accessible.
      *
@@ -188,21 +204,25 @@ class HealthService extends Base {
      */
     async #performHealthCheck() {
         const payload = {
-            status: 'healthy',
+            status   : 'healthy',
             timestamp: new Date().toISOString(),
-            database: {
+            database : {
                 process: DatabaseLifecycleService.getDatabaseStatus(),
                 connection: {
-                    connected: false,
+                    connected  : false,
                     collections: null
                 }
             },
             features: {
                 summarization: false
             },
+            startup: {
+                summarizationStatus : this.#startupSummarizationStatus || 'not_attempted',
+                summarizationDetails: this.#startupSummarizationDetails
+            },
             details: [],
             version: '1.0.0',
-            uptime: process.uptime()
+            uptime : process.uptime()
         };
 
         // Step 1: Check ChromaDB connectivity
@@ -348,6 +368,20 @@ class HealthService extends Base {
         }
     }
 
+    /**
+     * Records the result of startup summarization attempt.
+     * Called by the startup sequence in mcp-stdio.mjs
+     * @param {string} status - One of: 'completed', 'failed', 'skipped'
+     * @param {Object} details - Additional information about the summarization
+     */
+    recordStartupSummarization(status, details = null) {
+        this.#startupSummarizationStatus  = status;
+        this.#startupSummarizationDetails = details;
+
+        // Clear the cache to ensure next healthcheck returns updated info
+        this.clearCache();
+    }
+
     /**
      * Clears the health check cache, forcing the next call to perform a fresh check.
      *