@kb-labs/rest-api-app 2.14.0 → 2.17.0

package/dist/index.js

@@ -21,8 +21,6 @@ import { WORKFLOW_REDIS_CHANNEL } from '@kb-labs/workflow-constants';
 import { validatorCompiler, serializerCompiler } from 'fastify-type-provider-zod';
 import { z } from 'zod';
 import { errorEnvelopeSchema, ErrorCode, ErrorResponseSchema, JobsListResponseSchema, ListJobsQuerySchema, JobStatsResponseSchema, JobResponseSchema, JobActionResponseSchema } from '@kb-labs/rest-api-contracts';
-import { exec } from 'child_process';
-import { promisify } from 'util';
 import { readKbConfig } from '@kb-labs/core-config';
 import { AdapterNameSchema } from '@kb-labs/gateway-contracts';
 import fastifyCors from '@fastify/cors';
@@ -2694,8 +2692,9 @@ async function registerJobsRoutes(server, config, cronManager) {
           throw createError(503, "CRON_UNAVAILABLE", "Cron manager not available");
         }
         let jobs = cronManager.list();
-        if (request.query.status) {
-          jobs = jobs.filter((job) => job.status === request.query.status);
+        const query = request.query;
+        if (query.status) {
+          jobs = jobs.filter((job) => job.status === query.status);
         }
         return reply.send({ jobs });
       }
@@ -2900,261 +2899,15 @@ async function registerCacheRoutes(server, config, registry) {
     }
   });
 }
-var DEFAULT_CONFIG = {
-  model: "gpt-4",
-  temperature: 0.3,
-  maxTokens: 1500,
-  debug: false
-};
-var IncidentAnalyzer = class {
-  config;
-  logger;
-  constructor(config = {}, logger = console) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-    this.logger = logger;
-  }
-  /**
-   * Analyze incident using LLM
-   *
-   * @param incident - Incident to analyze
-   * @returns AI analysis result
-   */
-  async analyze(incident) {
-    this.log("info", "Analyzing incident", { id: incident.id, type: incident.type });
-    const prompt = this.buildAnalysisPrompt(incident);
-    try {
-      const result = await platform.llm.complete(prompt, {
-        model: this.config.model,
-        temperature: this.config.temperature,
-        maxTokens: this.config.maxTokens,
-        systemPrompt: this.getSystemPrompt()
-      });
-      this.log("debug", "LLM response received", {
-        length: result.content.length,
-        tokensUsed: result.usage ? result.usage.promptTokens + result.usage.completionTokens : void 0
-      });
-      const analysis = this.parseAnalysisResponse(result.content);
-      this.log("info", "Incident analysis complete", {
-        id: incident.id,
-        rootCausesCount: analysis.rootCauses.length,
-        recommendationsCount: analysis.recommendations.length
-      });
-      return analysis;
-    } catch (error) {
-      this.log("error", "Incident analysis failed", {
-        id: incident.id,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return this.getFallbackAnalysis(incident);
-    }
-  }
-  /**
-   * Build analysis prompt from incident data
-   * @private
-   */
-  buildAnalysisPrompt(incident) {
-    let prompt = `# Incident Analysis Request
-
-`;
-    prompt += `## Incident Overview
-`;
-    prompt += `- **ID**: ${incident.id}
-`;
-    prompt += `- **Type**: ${incident.type}
-`;
-    prompt += `- **Severity**: ${incident.severity}
-`;
-    prompt += `- **Title**: ${incident.title}
-`;
-    prompt += `- **Time**: ${new Date(incident.timestamp).toISOString()}
-
-`;
-    prompt += `## Description
-${incident.details}
-
-`;
-    if (incident.metadata && Object.keys(incident.metadata).length > 0) {
-      prompt += `## Metrics
-`;
-      prompt += "```json\n";
-      prompt += JSON.stringify(incident.metadata, null, 2);
-      prompt += "\n```\n\n";
-    }
-    if (incident.relatedData?.logs && incident.relatedData.logs.sampleErrors.length > 0) {
-      prompt += `## Related Error Logs (${incident.relatedData.logs.errorCount} total)
-`;
-      incident.relatedData.logs.sampleErrors.forEach((error, idx) => {
-        prompt += `${idx + 1}. ${error}
-`;
-      });
-      prompt += "\n";
-    }
-    if (incident.relatedData?.timeline && incident.relatedData.timeline.length > 0) {
-      prompt += `## Event Timeline
-`;
-      incident.relatedData.timeline.slice(0, 10).forEach((event) => {
-        const time = new Date(event.timestamp).toISOString();
-        prompt += `- [${time}] (${event.source}) ${event.event}
-`;
-      });
-      prompt += "\n";
-    }
-    if (incident.relatedData?.metrics) {
-      prompt += `## System Metrics
-`;
-      prompt += "```json\n";
-      prompt += JSON.stringify(incident.relatedData.metrics, null, 2);
-      prompt += "\n```\n\n";
-    }
-    prompt += `## Analysis Instructions
-`;
-    prompt += `Please analyze this incident and provide:
-`;
-    prompt += `1. A brief executive summary (2-3 sentences)
-`;
-    prompt += `2. Root causes with confidence scores (0.0-1.0) and evidence
-`;
-    prompt += `3. Patterns or trends you observe
-`;
-    prompt += `4. Actionable recommendations for resolution and prevention
-
-`;
-    prompt += `Format your response as JSON:
-`;
-    prompt += "```json\n";
-    prompt += `{
-`;
-    prompt += `  "summary": "Executive summary here",
-`;
-    prompt += `  "rootCauses": [
-`;
-    prompt += `    {
-`;
-    prompt += `      "factor": "Root cause description",
-`;
-    prompt += `      "confidence": 0.85,
-`;
-    prompt += `      "evidence": "Supporting evidence from logs/metrics"
-`;
-    prompt += `    }
-`;
-    prompt += `  ],
-`;
-    prompt += `  "patterns": ["Pattern 1", "Pattern 2"],
-`;
-    prompt += `  "recommendations": ["Recommendation 1", "Recommendation 2"]
-`;
-    prompt += `}
-`;
-    prompt += "```";
-    return prompt;
-  }
-  /**
-   * Get system prompt for incident analysis
-   * @private
-   */
-  getSystemPrompt() {
-    return `You are an expert SRE (Site Reliability Engineer) and incident response specialist.
-Your role is to analyze system incidents, identify root causes, and provide actionable recommendations.
-
-Guidelines:
-- Base your analysis on the actual data provided (logs, metrics, timeline)
-- Provide confidence scores based on available evidence (0.0 = no evidence, 1.0 = certain)
-- Focus on actionable recommendations that can prevent future incidents
-- Be concise but thorough - this is for production systems
-- Always respond with valid JSON matching the requested format`;
-  }
-  /**
-   * Parse LLM response into structured analysis
-   * @private
-   */
-  parseAnalysisResponse(response) {
-    try {
-      const jsonMatch = response.match(/```json\s*([\s\S]*?)\s*```/) ?? response.match(/```\s*([\s\S]*?)\s*```/) ?? [null, response];
-      const jsonStr = jsonMatch[1] || response;
-      const parsed = JSON.parse(jsonStr.trim());
-      return {
-        summary: parsed.summary || "No summary provided",
-        rootCauses: Array.isArray(parsed.rootCauses) ? parsed.rootCauses : [],
-        patterns: Array.isArray(parsed.patterns) ? parsed.patterns : [],
-        recommendations: Array.isArray(parsed.recommendations) ? parsed.recommendations : [],
-        analyzedAt: Date.now()
-      };
-    } catch (error) {
-      this.log("warn", "Failed to parse LLM response, using fallback", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return {
-        summary: response.substring(0, 200),
-        rootCauses: [],
-        patterns: [],
-        recommendations: [],
-        analyzedAt: Date.now()
-      };
-    }
-  }
-  /**
-   * Get fallback analysis when LLM is unavailable
-   * @private
-   */
-  getFallbackAnalysis(incident) {
-    const errorCount = incident.relatedData?.logs?.errorCount ?? 0;
-    const sampleErrors = incident.relatedData?.logs?.sampleErrors ?? [];
-    return {
-      summary: `${incident.severity} ${incident.type} incident detected. ${errorCount} errors logged.`,
-      rootCauses: [
-        {
-          factor: incident.title,
-          confidence: 0.5,
-          evidence: incident.details
-        }
-      ],
-      patterns: sampleErrors.length > 0 ? [`Multiple error types detected: ${sampleErrors.length} unique errors`] : [],
-      recommendations: [
-        "Review related error logs for stack traces",
-        "Check system metrics during incident timeframe",
-        "Verify external dependencies are operational"
-      ],
-      analyzedAt: Date.now()
-    };
-  }
-  log(level, message, meta) {
-    if (level === "debug" && !this.config.debug) {
-      return;
-    }
-    const prefix = "[IncidentAnalyzer]";
-    if (this.logger[level]) {
-      if (meta) {
-        this.logger[level]({ ...meta }, `${prefix} ${message}`);
-      } else {
-        this.logger[level](`${prefix} ${message}`);
-      }
-    } else {
-      console.log(`${prefix} [${level}] ${message}`, meta ?? "");
-    }
-  }
-};
-
-// src/routes/observability.ts
-var execAsync = promisify(exec);
-var DEVKIT_CACHE_KEY = "observability:devkit-health";
-var DEVKIT_CACHE_TTL_MS = 10 * 60 * 1e3;
-async function registerObservabilityRoutes(fastify, config, repoRoot, historicalMetrics, incidentStorage, platform19) {
+async function registerObservabilityRoutes(fastify, config, repoRoot, historicalMetrics, platform16) {
   const basePath = normalizeBasePath(config.basePath);
   const stateBrokerPaths = resolvePaths(basePath, "/observability/state-broker");
-  const devkitPaths = resolvePaths(basePath, "/observability/devkit");
   const systemMetricsPaths = resolvePaths(basePath, "/observability/system-metrics");
   const metricsHistoryPaths = resolvePaths(basePath, "/observability/metrics/history");
   const metricsHeatmapPaths = resolvePaths(basePath, "/observability/metrics/heatmap");
-  const incidentsListPaths = resolvePaths(basePath, "/observability/incidents");
-  const incidentsDetailPaths = resolvePaths(basePath, "/observability/incidents/:id");
-  const incidentsCreatePaths = resolvePaths(basePath, "/observability/incidents");
-  const incidentsHistoryPaths = resolvePaths(basePath, "/observability/incidents/history");
-  const incidentsResolvePaths = resolvePaths(basePath, "/observability/incidents/:id/resolve");
-  const incidentsAnalyzePaths = resolvePaths(basePath, "/observability/incidents/:id/analyze");
   const insightsChatPaths = resolvePaths(basePath, "/observability/insights/chat");
   for (const path3 of stateBrokerPaths) {
-    fastify.get(path3, async (_request, reply) => {
+    fastify.get(path3, { schema: { tags: ["Observability"], summary: "State Broker statistics" } }, async (_request, reply) => {
       try {
         const stateBrokerUrl = process.env.KB_STATE_DAEMON_URL || "http://localhost:7777";
         fastify.log.debug({ url: stateBrokerUrl }, "Fetching State Broker stats");
@@ -3193,7 +2946,7 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
           }
         };
       } catch (error) {
-        platform19?.logger.error("Failed to fetch State Broker stats", error instanceof Error ? error : new Error(String(error)));
+        platform16?.logger.error("Failed to fetch State Broker stats", error instanceof Error ? error : new Error(String(error)));
         const isTimeout = error instanceof Error && error.name === "AbortError";
         return reply.code(503).send({
           ok: false,
@@ -3208,105 +2961,10 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
       }
     });
   }
-  for (const path3 of devkitPaths) {
-    fastify.get(path3, async (_request, reply) => {
-      const now = Date.now();
-      if (platform19?.cache) {
-        try {
-          const cached = await platform19.cache.get(DEVKIT_CACHE_KEY);
-          if (cached && now < cached.expiresAt) {
-            const remainingTtl = Math.round((cached.expiresAt - now) / 1e3);
-            fastify.log.debug({ remainingTtl }, "Returning cached DevKit health from platform.cache");
-            return {
-              ok: true,
-              data: cached.data,
-              meta: {
-                source: "devkit-cli",
-                repoRoot,
-                cached: true,
-                cachedAt: cached.timestamp,
-                expiresAt: cached.expiresAt,
-                ttlSeconds: remainingTtl
-              }
-            };
-          }
-        } catch (cacheError) {
-          fastify.log.warn({ err: cacheError }, "Failed to read from platform.cache, proceeding without cache");
-        }
-      }
-      try {
-        fastify.log.debug({ cwd: repoRoot }, "Executing DevKit health check (cache miss)");
-        const { stdout, stderr } = await execAsync("npx kb-devkit-health --json", {
-          cwd: repoRoot,
-          timeout: 3e4,
-          // 30s timeout
-          env: {
-            ...process.env,
-            // Ensure DevKit runs in non-interactive mode
-            CI: "true"
-          }
-        });
-        if (stderr) {
-          fastify.log.warn({ stderr }, "DevKit health check produced warnings");
-        }
-        const health = JSON.parse(stdout);
-        const expiresAt = now + DEVKIT_CACHE_TTL_MS;
-        if (platform19?.cache) {
-          try {
-            await platform19.cache.set(DEVKIT_CACHE_KEY, {
-              data: health,
-              timestamp: now,
-              expiresAt
-            }, DEVKIT_CACHE_TTL_MS);
-            fastify.log.debug({
-              healthScore: health.healthScore,
-              grade: health.grade,
-              cachedUntil: new Date(expiresAt).toISOString()
-            }, "DevKit health check completed and cached in platform.cache");
-          } catch (cacheError) {
-            fastify.log.warn({ err: cacheError }, "Failed to write to platform.cache");
-          }
-        }
-        return {
-          ok: true,
-          data: health,
-          meta: {
-            source: "devkit-cli",
-            repoRoot,
-            command: "npx kb-devkit-health --json",
-            cached: false,
-            cachedAt: now,
-            expiresAt,
-            ttlSeconds: DEVKIT_CACHE_TTL_MS / 1e3
-          }
-        };
-      } catch (error) {
-        let partialData = null;
-        if (error && typeof error === "object" && "stdout" in error) {
-          try {
-            partialData = JSON.parse(error.stdout);
-          } catch {
-            partialData = null;
-          }
-        }
-        platform19?.logger.error("Failed to execute DevKit health check", error instanceof Error ? error : new Error(String(error)));
-        return reply.code(500).send({
-          ok: false,
-          error: {
-            code: "DEVKIT_ERROR",
-            message: error instanceof Error ? error.message : "Failed to execute DevKit health check",
-            details: {
-              partialData
-            }
-          }
-        });
-      }
-    });
-  }
   for (const path3 of systemMetricsPaths) {
-    fastify.get(path3, async (_request, reply) => {
+    fastify.get(path3, { schema: { tags: ["Observability"], summary: "System resource metrics" } }, async (_request, reply) => {
       try {
-        if (!platform19?.cache) {
+        if (!platform16?.cache) {
           return reply.code(503).send({
             ok: false,
             error: {
@@ -3318,17 +2976,17 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
         fastify.log.debug("Fetching system metrics from all instances");
         const allMetrics = [];
         try {
-          if ("scan" in platform19.cache && typeof platform19.cache.scan === "function") {
-            const keys = await platform19.cache.scan("system-metrics:*");
+          if ("scan" in platform16.cache && typeof platform16.cache.scan === "function") {
+            const keys = await platform16.cache.scan("system-metrics:*");
             for (const key of keys) {
-              const metrics = await platform19.cache.get(key);
+              const metrics = await platform16.cache.get(key);
               if (metrics) {
                 allMetrics.push(metrics);
               }
             }
           } else {
             const currentInstanceId = hostname();
-            const metrics = await platform19.cache.get(`system-metrics:${currentInstanceId}`);
+            const metrics = await platform16.cache.get(`system-metrics:${currentInstanceId}`);
             if (metrics) {
               allMetrics.push(metrics);
             }
@@ -3337,7 +2995,7 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
         } catch (scanError) {
           fastify.log.warn({ err: scanError }, "Failed to scan platform.cache for system metrics");
           const currentInstanceId = hostname();
-          const metrics = await platform19.cache.get(`system-metrics:${currentInstanceId}`);
+          const metrics = await platform16.cache.get(`system-metrics:${currentInstanceId}`);
           if (metrics) {
             allMetrics.push(metrics);
           }
@@ -3385,7 +3043,7 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
           }
         };
       } catch (error) {
-        platform19?.logger.error("Failed to fetch system metrics", error instanceof Error ? error : new Error(String(error)));
+        platform16?.logger.error("Failed to fetch system metrics", error instanceof Error ? error : new Error(String(error)));
         return reply.code(500).send({
           ok: false,
           error: {
@@ -3399,6 +3057,8 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
   for (const path3 of metricsHistoryPaths) {
     fastify.get(path3, {
       schema: {
+        tags: ["Observability"],
+        summary: "Historical time-series metrics",
         querystring: {
           type: "object",
           properties: {
@@ -3481,7 +3141,7 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
           }
         };
       } catch (error) {
-        platform19?.logger.error("Failed to query historical metrics", error instanceof Error ? error : new Error(String(error)), { query });
+        platform16?.logger.error("Failed to query historical metrics", error instanceof Error ? error : new Error(String(error)), { query });
         return reply.code(500).send({
           ok: false,
           error: {
@@ -3495,6 +3155,8 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
   for (const path3 of metricsHeatmapPaths) {
     fastify.get(path3, {
       schema: {
+        tags: ["Observability"],
+        summary: "Metrics heatmap data",
         querystring: {
           type: "object",
           properties: {
@@ -3570,7 +3232,7 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
           }
         };
       } catch (error) {
-        platform19?.logger.error("Failed to query heatmap data", error instanceof Error ? error : new Error(String(error)), { query });
+        platform16?.logger.error("Failed to query heatmap data", error instanceof Error ? error : new Error(String(error)), { query });
         return reply.code(500).send({
           ok: false,
           error: {
@@ -3581,310 +3243,11 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
       }
     });
   }
-  for (const path3 of incidentsListPaths) {
-    fastify.get(path3, {
-      schema: {
-        querystring: {
-          type: "object",
-          properties: {
-            limit: { type: "integer", default: 50 },
-            severity: {
-              type: "string",
-              enum: ["critical", "warning", "info"]
-            },
-            type: {
-              type: "string",
-              enum: ["error_rate", "latency_spike", "plugin_failure", "adapter_failure", "system_health", "custom"]
-            },
-            from: { type: "integer" },
-            to: { type: "integer" },
-            includeResolved: { type: "boolean", default: false }
-          }
-        }
-      }
-    }, async (request, reply) => {
-      if (!incidentStorage) {
-        return reply.code(503).send({
-          ok: false,
-          error: {
-            code: "INCIDENTS_NOT_CONFIGURED",
-            message: "Incident storage is not configured"
-          }
-        });
-      }
-      try {
-        const query = request.query;
-        const incidents = await incidentStorage.queryIncidents({
-          limit: query.limit ?? 50,
-          severity: query.severity,
-          type: query.type,
-          from: query.from,
-          to: query.to,
-          includeResolved: query.includeResolved ?? false
-        });
-        const stats = await incidentStorage.getStats();
-        return {
-          ok: true,
-          data: {
-            incidents,
-            summary: {
-              total: stats.total,
-              unresolved: stats.unresolved,
-              bySeverity: stats.bySeverity,
-              showing: incidents.length
-            }
-          }
-        };
-      } catch (error) {
-        fastify.log.error({ err: error }, "Failed to list incidents");
-        return reply.code(500).send({
-          ok: false,
-          error: {
-            code: "INCIDENTS_LIST_ERROR",
-            message: error instanceof Error ? error.message : "Failed to list incidents"
-          }
-        });
-      }
-    });
-  }
-  for (const path3 of incidentsDetailPaths) {
-    fastify.get(path3, {
-      schema: {
-        params: {
-          type: "object",
-          properties: {
-            id: { type: "string" }
-          },
-          required: ["id"]
-        }
-      }
-    }, async (request, reply) => {
-      if (!incidentStorage) {
-        return reply.code(503).send({
-          ok: false,
-          error: {
-            code: "INCIDENTS_NOT_CONFIGURED",
-            message: "Incident storage is not configured"
-          }
-        });
-      }
-      const { id } = request.params;
-      try {
-        const incident = await incidentStorage.getIncident(id);
-        if (!incident) {
-          return reply.code(404).send({
-            ok: false,
-            error: {
-              code: "INCIDENT_NOT_FOUND",
-              message: `Incident ${id} not found`
-            }
-          });
-        }
-        if (platform19?.analytics) {
-          platform19.analytics.track("incident.viewed", {
-            incidentId: id,
-            type: incident.type,
-            severity: incident.severity,
-            isResolved: !!incident.resolvedAt,
-            hasAIAnalysis: !!incident.aiAnalysis
-          }).catch(() => {
-          });
-        }
-        return {
-          ok: true,
-          data: incident
-        };
-      } catch (error) {
-        fastify.log.error({ err: error }, "Failed to get incident");
-        return reply.code(500).send({
-          ok: false,
-          error: {
-            code: "INCIDENT_GET_ERROR",
-            message: error instanceof Error ? error.message : "Failed to get incident"
-          }
-        });
-      }
-    });
-  }
-  for (const path3 of incidentsCreatePaths) {
-    fastify.post(path3, {
-      schema: {
-        body: {
-          type: "object",
-          properties: {
-            type: {
-              type: "string",
-              enum: ["error_rate", "latency_spike", "plugin_failure", "adapter_failure", "system_health", "custom"]
-            },
-            severity: {
-              type: "string",
-              enum: ["critical", "warning", "info"]
-            },
-            title: { type: "string" },
-            details: { type: "string" },
-            rootCause: { type: "string" },
-            affectedServices: {
-              type: "array",
-              items: { type: "string" }
-            },
-            timestamp: { type: "number" },
-            metadata: { type: "object" }
-          },
-          required: ["type", "severity", "title", "details"]
-        }
-      }
-    }, async (request, reply) => {
-      if (!incidentStorage) {
-        return reply.code(503).send({
-          ok: false,
-          error: {
-            code: "INCIDENT_STORAGE_UNAVAILABLE",
-            message: "Incident storage is not initialized"
-          }
-        });
-      }
-      try {
-        const payload = request.body;
-        const incident = await incidentStorage.createIncident(payload);
-        return {
-          ok: true,
-          data: incident,
-          meta: {
-            source: "incident-storage"
-          }
-        };
-      } catch (error) {
-        platform19?.logger.error("Failed to create incident", error instanceof Error ? error : new Error(String(error)));
-        return reply.code(500).send({
-          ok: false,
-          error: {
-            code: "INCIDENT_CREATE_ERROR",
-            message: error instanceof Error ? error.message : "Failed to create incident"
-          }
-        });
-      }
-    });
-  }
-  for (const path3 of incidentsHistoryPaths) {
-    fastify.get(path3, {
-      schema: {
-        querystring: {
-          type: "object",
-          properties: {
-            limit: { type: "integer", minimum: 1, maximum: 500 },
-            severity: { type: "string", enum: ["critical", "warning", "info"] },
-            type: {
-              type: "string",
-              enum: ["error_rate", "latency_spike", "plugin_failure", "adapter_failure", "system_health", "custom"]
-            },
-            from: { type: "integer" },
-            to: { type: "integer" },
-            includeResolved: { type: "boolean" }
-          }
-        }
-      }
-    }, async (request, reply) => {
-      if (!incidentStorage) {
-        return reply.code(503).send({
-          ok: false,
-          error: {
-            code: "INCIDENT_STORAGE_UNAVAILABLE",
-            message: "Incident storage is not initialized"
-          }
-        });
-      }
-      try {
-        const query = request.query;
-        const incidents = await incidentStorage.queryIncidents({
-          limit: query.limit ?? 50,
-          severity: query.severity,
-          type: query.type,
-          from: query.from,
-          to: query.to,
-          includeResolved: query.includeResolved ?? false
-        });
-        return {
-          ok: true,
-          data: incidents,
-          meta: {
-            source: "incident-storage",
-            count: incidents.length
-          }
-        };
-      } catch (error) {
-        platform19?.logger.error("Failed to query incidents", error instanceof Error ? error : new Error(String(error)));
-        return reply.code(500).send({
-          ok: false,
-          error: {
-            code: "INCIDENT_QUERY_ERROR",
-            message: error instanceof Error ? error.message : "Failed to query incidents"
-          }
-        });
-      }
-    });
-  }
-  for (const path3 of incidentsResolvePaths) {
-    fastify.post(path3, {
-      schema: {
-        params: {
-          type: "object",
-          properties: {
-            id: { type: "string" }
-          },
-          required: ["id"]
-        },
-        body: {
-          type: "object",
-          properties: {
-            resolutionNotes: { type: "string" }
-          }
-        }
-      }
-    }, async (request, reply) => {
-      if (!incidentStorage) {
-        return reply.code(503).send({
-          ok: false,
-          error: {
-            code: "INCIDENT_STORAGE_UNAVAILABLE",
-            message: "Incident storage is not initialized"
-          }
-        });
-      }
-      try {
-        const { id } = request.params;
-        const body = request.body;
-        const incident = await incidentStorage.resolveIncident(id, body.resolutionNotes);
-        if (!incident) {
-          return reply.code(404).send({
-            ok: false,
-            error: {
-              code: "INCIDENT_NOT_FOUND",
-              message: `Incident with id ${id} not found`
-            }
-          });
-        }
-        return {
-          ok: true,
-          data: incident,
-          meta: {
-            source: "incident-storage"
-          }
-        };
-      } catch (error) {
-        platform19?.logger.error("Failed to resolve incident", error instanceof Error ? error : new Error(String(error)));
-        return reply.code(500).send({
-          ok: false,
-          error: {
-            code: "INCIDENT_RESOLVE_ERROR",
-            message: error instanceof Error ? error.message : "Failed to resolve incident"
-          }
-        });
-      }
-    });
-  }
   for (const path3 of insightsChatPaths) {
     fastify.post(path3, {
       schema: {
+        tags: ["Observability"],
+        summary: "AI-powered observability insights chat",
         body: {
           type: "object",
           properties: {
@@ -3893,7 +3256,6 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
               type: "object",
               properties: {
                 includeMetrics: { type: "boolean" },
-                includeIncidents: { type: "boolean" },
                 includeHistory: { type: "boolean" },
                 timeRange: { type: "string", enum: ["1h", "6h", "24h", "7d"] },
                 plugins: { type: "array", items: { type: "string" } }
@@ -3904,7 +3266,7 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
         }
       }
     }, async (request, reply) => {
-      if (!platform19?.llm) {
+      if (!platform16?.llm) {
         return reply.code(503).send({
           ok: false,
           error: {
@@ -3917,7 +3279,6 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
         const body = request.body;
         const contextConfig = {
           includeMetrics: body.context?.includeMetrics ?? true,
-          includeIncidents: body.context?.includeIncidents ?? true,
           includeHistory: body.context?.includeHistory ?? true,
           timeRange: body.context?.timeRange ?? "24h",
           plugins: body.context?.plugins ?? []
@@ -3958,26 +3319,6 @@ async function registerObservabilityRoutes(fastify, config, repoRoot, historical
             fastify.log.warn({ err: metricsError }, "Failed to build metrics context for insights");
           }
         }
-        if (contextConfig.includeIncidents && incidentStorage) {
-          try {
-            const incidents = await incidentStorage.queryIncidents({ limit: 10 });
-            if (incidents.length > 0) {
-              contextText += `
-## Recent Incidents (${incidents.length})
-`;
-              for (const incident of incidents) {
-                contextText += `- [${incident.severity.toUpperCase()}] ${incident.title}
-`;
-                if (incident.details) {
-                  contextText += `  Details: ${incident.details.slice(0, 100)}${incident.details.length > 100 ? "..." : ""}
-`;
-                }
-              }
-            }
-          } catch (incidentError) {
-            fastify.log.warn({ err: incidentError }, "Failed to fetch incidents for insights context");
-          }
-        }
         const prompt = `You are an AI assistant analyzing a software platform's observability data.
 
 ${contextText}
@@ -3991,15 +3332,15 @@ Provide a clear, actionable response based on the data above. Include:
 
 Be concise but thorough. Use markdown formatting.`;
         fastify.log.debug({ question: body.question, contextLength: contextText.length }, "Calling LLM for insights");
-        const result = await platform19.llm.complete(prompt, {
+        const result = await platform16.llm.complete(prompt, {
           systemPrompt: "You are a DevOps and SRE expert assistant. Analyze system metrics and provide actionable insights. Be concise, technical, and helpful.",
           temperature: 0.7,
           maxTokens: 1e3
         });
         const totalTokens = result.usage.promptTokens + result.usage.completionTokens;
         fastify.log.debug({ tokensUsed: totalTokens }, "LLM response received for insights");
-        if (platform19.analytics) {
-          platform19.analytics.track("ai_insights.chat", {
+        if (platform16.analytics) {
+          platform16.analytics.track("ai_insights.chat", {
             questionLength: body.question.length,
             contextIncluded: Object.keys(contextConfig).filter((k) => contextConfig[k]),
             timeRange: contextConfig.timeRange,
@@ -4026,246 +3367,27 @@ Be concise but thorough. Use markdown formatting.`;
             source: "llm-insights",
             model: result.model
           }
-        };
-      } catch (error) {
-        platform19?.logger.error("Failed to generate insights", error instanceof Error ? error : new Error(String(error)));
-        if (platform19?.analytics) {
-          platform19.analytics.track("ai_insights.error", {
-            error: error instanceof Error ? error.message : "Unknown error",
-            questionLength: request.body?.question?.length ?? 0
-          }).catch(() => {
-          });
-        }
-        return reply.code(500).send({
-          ok: false,
-          error: {
-            code: "INSIGHTS_ERROR",
-            message: error instanceof Error ? error.message : "Failed to generate insights"
-          }
-        });
-      }
-    });
-  }
-  for (const path3 of incidentsAnalyzePaths) {
-    fastify.post(path3, async (request, reply) => {
-      if (!incidentStorage) {
-        return reply.code(503).send({
-          ok: false,
-          error: {
-            code: "INCIDENTS_NOT_CONFIGURED",
-            message: "Incident storage is not configured"
-          }
-        });
-      }
-      const { id } = request.params;
-      try {
-        const incident = await incidentStorage.getIncident(id);
-        if (!incident) {
-          return reply.code(404).send({
-            ok: false,
-            error: {
-              code: "INCIDENT_NOT_FOUND",
-              message: `Incident ${id} not found`
-            }
-          });
-        }
-        if (incident.aiAnalysis && incident.aiAnalyzedAt) {
-          const ageMs = Date.now() - incident.aiAnalyzedAt;
-          const ageMinutes = Math.floor(ageMs / 6e4);
-          if (ageMs < 60 * 60 * 1e3) {
-            return {
-              ok: true,
-              data: {
-                ...incident.aiAnalysis,
-                cached: true,
-                analyzedAt: incident.aiAnalyzedAt,
-                ageMinutes
-              }
-            };
-          }
-        }
-        const analyzer = new IncidentAnalyzer(
-          {
-            debug: process.env.NODE_ENV !== "production"
-          },
-          fastify.log
-        );
-        const analysis = await analyzer.analyze(incident);
-        await incidentStorage.updateAIAnalysis(id, analysis);
-        if (platform19?.analytics) {
-          platform19.analytics.track("incident.analyzed", {
-            incidentId: id,
-            type: incident.type,
-            severity: incident.severity,
-            rootCausesCount: analysis.rootCauses.length,
-            recommendationsCount: analysis.recommendations.length
-          }).catch(() => {
-          });
-        }
-        return {
-          ok: true,
-          data: {
-            ...analysis,
-            cached: false
-          }
-        };
-      } catch (error) {
-        fastify.log.error({ err: error }, "Failed to analyze incident");
-        if (platform19?.analytics) {
-          platform19.analytics.track("incident.analysis_error", {
-            incidentId: id,
-            error: error instanceof Error ? error.message : "Unknown error"
-          }).catch(() => {
-          });
-        }
-        return reply.code(500).send({
-          ok: false,
-          error: {
-            code: "ANALYSIS_ERROR",
-            message: error instanceof Error ? error.message : "Failed to analyze incident"
-          }
-        });
-      }
-    });
-  }
-  const testCreateIncidentPaths = resolvePaths(basePath, "/test/create-incident");
-  for (const path3 of testCreateIncidentPaths) {
-    fastify.post(path3, async (request, reply) => {
-      if (!incidentStorage) {
-        return reply.code(500).send({
-          ok: false,
-          error: { code: "INCIDENT_STORAGE_NOT_INITIALIZED", message: "Incident storage not initialized" }
-        });
-      }
-      try {
-        const {
-          type = "custom",
-          severity = "warning",
-          title = "Test Incident",
-          details,
-          relatedData
-        } = request.body;
-        const incident = await incidentStorage.createIncident({
-          type,
-          severity,
-          title,
-          details: details || "This is a test incident created manually for testing purposes.",
-          timestamp: Date.now(),
-          metadata: {
-            testMode: true,
-            createdVia: "test-endpoint"
-          },
-          relatedData: relatedData || {
-            timeline: [
-              {
-                timestamp: Date.now(),
-                event: "Test incident created via /test/create-incident",
-                source: "manual"
-              }
-            ]
-          }
-        });
-        fastify.log.info({ id: incident.id }, "Test incident created");
-        return { ok: true, data: incident };
-      } catch (error) {
-        fastify.log.error({ err: error }, "Failed to create test incident");
-        return reply.code(500).send({
-          ok: false,
-          error: {
-            code: "TEST_INCIDENT_CREATION_FAILED",
-            message: error instanceof Error ? error.message : "Failed to create test incident"
-          }
-        });
-      }
-    });
-  }
-  const testTriggerErrorsPaths = resolvePaths(basePath, "/test/trigger-errors");
-  for (const path3 of testTriggerErrorsPaths) {
-    fastify.get(path3, async (request, reply) => {
-      const { count = 10 } = request.query;
-      const errorCount = Math.min(Math.max(1, parseInt(count, 10) || 10), 100);
-      fastify.log.info(`Triggering ${errorCount} test errors`);
-      for (let i = 0; i < errorCount; i++) {
-        platform19?.logger.error(`Test error ${i + 1}/${errorCount}`, void 0, {
-          testMode: true,
-          errorNumber: i + 1,
-          totalErrors: errorCount
-        });
-        if (i === errorCount - 1) {
-          return reply.code(500).send({
-            ok: false,
-            error: {
-              code: "TEST_ERROR_TRIGGERED",
-              message: `Generated ${errorCount} test errors. Check /observability/incidents in ~30 seconds for auto-created incident.`
-            }
+        };
+      } catch (error) {
+        platform16?.logger.error("Failed to generate insights", error instanceof Error ? error : new Error(String(error)));
+        if (platform16?.analytics) {
+          platform16.analytics.track("ai_insights.error", {
+            error: error instanceof Error ? error.message : "Unknown error",
+            questionLength: request.body?.question?.length ?? 0
+          }).catch(() => {
           });
         }
-      }
-      return {
-        ok: true,
-        message: `Triggered ${errorCount} test errors. Incident should be auto-created in next detection cycle (~30s).`
-      };
-    });
-  }
-  const testSimulateLatencyPaths = resolvePaths(basePath, "/test/simulate-latency");
-  for (const path3 of testSimulateLatencyPaths) {
-    fastify.get(path3, async (request, reply) => {
-      const { delay = 2e3 } = request.query;
-      const delayMs = Math.min(Math.max(100, parseInt(delay, 10) || 2e3), 1e4);
-      fastify.log.info(`Simulating ${delayMs}ms latency`);
-      await new Promise((resolve3) => {
-        setTimeout(resolve3, delayMs);
-      });
-      return {
-        ok: true,
-        message: `Simulated ${delayMs}ms latency. Call this endpoint multiple times to trigger latency_spike incident.`,
-        actualDelay: delayMs
-      };
-    });
-  }
-  const testBulkErrorsPaths = resolvePaths(basePath, "/test/bulk-errors");
-  for (const path3 of testBulkErrorsPaths) {
-    fastify.post(path3, async (request, reply) => {
-      const { successCount = 10, errorCount = 50 } = request.body;
-      fastify.log.info({ successCount, errorCount }, "Generating bulk requests for incident testing");
-      for (let i = 0; i < successCount; i++) {
-        platform19?.logger.info(`Bulk test - success ${i + 1}/${successCount}`);
-      }
-      const testEndpoints = [
-        "POST /api/v1/test/endpoint-a",
-        "GET /api/v1/test/endpoint-b",
-        "PUT /api/v1/test/endpoint-c",
-        "DELETE /api/v1/test/endpoint-d",
-        "POST /api/v1/test/endpoint-e"
-      ];
-      for (let i = 0; i < errorCount; i++) {
-        const endpoint = testEndpoints[i % testEndpoints.length];
-        const errorTypes = [
-          "Connection timeout",
-          "Validation failed",
-          "Database query error",
-          "Authentication failed",
-          "Rate limit exceeded"
-        ];
-        const errorType = errorTypes[i % errorTypes.length];
-        platform19?.logger.error(`${errorType}: ${endpoint}`, void 0, {
-          testMode: true,
-          bulkTest: true,
-          errorIndex: i,
-          endpoint
+        return reply.code(500).send({
+          ok: false,
+          error: {
+            code: "INSIGHTS_ERROR",
+            message: error instanceof Error ? error.message : "Failed to generate insights"
+          }
         });
       }
-      const totalRequests = successCount + errorCount;
-      const errorRate = errorCount / totalRequests * 100;
-      return {
-        ok: true,
-        message: `Generated ${totalRequests} requests (${successCount} success, ${errorCount} errors)`,
-        errorRate: `${errorRate.toFixed(1)}%`,
-        note: "Incident should be auto-created in next detection cycle (~30s)"
-      };
     });
   }
-  fastify.log.info("Observability routes registered (including test endpoints)");
+  fastify.log.info("Observability routes registered");
 }
 async function registerAnalyticsRoutes(fastify, config) {
   const basePath = normalizeBasePath(config.basePath);
@@ -5598,7 +4720,7 @@ function generateFallbackSummary(stats, logs) {
   return summary;
 }
 async function registerLogRoutes(server, config, eventHub) {
-  server.get("/api/v1/logs", async (request, reply) => {
+  server.get("/api/v1/logs", { schema: { tags: ["Logs"], summary: "Query logs with filters" } }, async (request, reply) => {
     try {
       const limit = request.query.limit ? parseInt(request.query.limit, 10) : 100;
       const offset = request.query.offset ? parseInt(request.query.offset, 10) : 0;
@@ -5656,6 +4778,7 @@ async function registerLogRoutes(server, config, eventHub) {
   });
   server.get(
     "/api/v1/logs/:id",
+    { schema: { tags: ["Logs"], summary: "Get log entry by ID" } },
     async (request, reply) => {
       try {
         const log = await platform.logs.getById(request.params.id);
@@ -5689,6 +4812,7 @@ async function registerLogRoutes(server, config, eventHub) {
   );
   server.get(
     "/api/v1/logs/:id/related",
+    { schema: { tags: ["Logs"], summary: "Get logs related to a specific entry" } },
     async (request, reply) => {
       try {
         const log = await platform.logs.getById(request.params.id);
@@ -5717,7 +4841,7 @@ async function registerLogRoutes(server, config, eventHub) {
       }
     }
   );
-  server.get("/api/v1/logs/stream", async (request, reply) => {
+  server.get("/api/v1/logs/stream", { schema: { hide: true } }, async (request, reply) => {
     const caps = platform.logs.getCapabilities();
     if (!caps.hasStreaming) {
       return reply.code(503).send({
@@ -5775,7 +4899,7 @@ async function registerLogRoutes(server, config, eventHub) {
     await new Promise(() => {
     });
   });
-  server.get("/api/v1/logs/stats", async (request, reply) => {
+  server.get("/api/v1/logs/stats", { schema: { tags: ["Logs"], summary: "Get log storage statistics" } }, async (request, reply) => {
     try {
       const stats = await platform.logs.getStats();
       const caps = platform.logs.getCapabilities();
@@ -5805,7 +4929,7 @@ async function registerLogRoutes(server, config, eventHub) {
       });
     }
   });
-  server.post("/api/v1/logs/summarize", async (request, reply) => {
+  server.post("/api/v1/logs/summarize", { schema: { tags: ["Logs"], summary: "AI-powered log summarization" } }, async (request, reply) => {
     const { timeRange, filters, groupBy, question, includeContext } = request.body;
     try {
       const query = {
@@ -6197,7 +5321,7 @@ async function registerDebugRoutes(fastify, config) {
 }
 
 // src/services/historical-metrics.ts
-var DEFAULT_CONFIG2 = {
+var DEFAULT_CONFIG = {
   intervalMs: 5e3,
   maxPoints: {
     "1m": 12,
@@ -6216,7 +5340,7 @@ var HistoricalMetricsCollector = class {
   startTimeMs = Date.now();
   constructor(cache, config = {}, logger = console) {
     this.cache = cache;
-    this.config = { ...DEFAULT_CONFIG2, ...config, maxPoints: { ...DEFAULT_CONFIG2.maxPoints, ...config.maxPoints } };
+    this.config = { ...DEFAULT_CONFIG, ...config, maxPoints: { ...DEFAULT_CONFIG.maxPoints, ...config.maxPoints } };
     this.logger = logger;
   }
   /**
@@ -6516,754 +5640,6 @@ var HistoricalMetricsCollector = class {
     }
   }
 };
-var DEFAULT_CONFIG3 = {
-  ttlMs: 30 * 24 * 60 * 60 * 1e3,
-  // 30 days (not used with SQLite, kept for compatibility)
-  maxIncidents: 1e3,
-  // Not enforced with SQLite, use retention policy instead
-  debug: false
-};
-var IncidentStorage = class {
-  db;
-  config;
-  logger;
-  constructor(db, config = {}, logger = console) {
-    this.db = db;
-    this.config = { ...DEFAULT_CONFIG3, ...config };
-    this.logger = logger;
-  }
-  /**
-   * Create a new incident record
-   */
-  async createIncident(payload) {
-    const id = `inc-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-    const timestamp = payload.timestamp ?? Date.now();
-    if (!payload.type || !payload.severity || !payload.title) {
-      throw new Error("Incident must have type, severity, and title");
-    }
-    const relatedLogsCount = payload.relatedData?.logs?.errorCount ?? 0;
-    const relatedLogsSample = payload.relatedData?.logs ? JSON.stringify(payload.relatedData.logs) : null;
-    const relatedMetrics = payload.relatedData?.metrics ? JSON.stringify(payload.relatedData.metrics) : null;
-    const timeline = payload.relatedData?.timeline ? JSON.stringify(payload.relatedData.timeline) : null;
-    await this.db.query(
-      `INSERT INTO incidents (
-        id, type, severity, title, details, timestamp,
-        resolved_at, resolution_notes,
-        affected_services, metadata,
-        related_logs_count, related_logs_sample, related_metrics, timeline
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-      [
-        id,
-        payload.type,
-        payload.severity,
-        payload.title,
-        payload.details,
-        timestamp,
-        payload.resolvedAt ?? null,
-        payload.resolutionNotes ?? null,
-        payload.affectedServices ? JSON.stringify(payload.affectedServices) : null,
-        payload.metadata ? JSON.stringify(payload.metadata) : null,
-        relatedLogsCount,
-        relatedLogsSample,
-        relatedMetrics,
-        timeline
-      ]
-    );
-    this.log("info", "Incident created", {
-      id,
-      type: payload.type,
-      severity: payload.severity
-    });
-    const created = await this.getIncident(id);
-    if (!created) {
-      throw new Error("Failed to retrieve created incident");
-    }
-    return created;
-  }
-  /**
-   * Get incident by ID
-   */
-  async getIncident(id) {
-    const result = await this.db.query(
-      "SELECT * FROM incidents WHERE id = ?",
-      [id]
-    );
-    if (result.rows.length === 0) {
-      return null;
-    }
-    return this.rowToIncident(result.rows[0]);
-  }
-  /**
-   * Query incidents with filters
-   */
-  async queryIncidents(options = {}) {
-    const {
-      limit = 50,
-      severity,
-      type,
-      from,
-      to,
-      includeResolved = false
-    } = options;
-    const conditions = [];
-    const params = [];
-    if (severity) {
-      const severityList = Array.isArray(severity) ? severity : [severity];
-      conditions.push(`severity IN (${severityList.map(() => "?").join(", ")})`);
-      params.push(...severityList);
-    }
-    if (type) {
-      const typeList = Array.isArray(type) ? type : [type];
-      conditions.push(`type IN (${typeList.map(() => "?").join(", ")})`);
-      params.push(...typeList);
-    }
-    if (from) {
-      conditions.push("timestamp >= ?");
-      params.push(from);
-    }
-    if (to) {
-      conditions.push("timestamp <= ?");
-      params.push(to);
-    }
-    if (!includeResolved) {
-      conditions.push("resolved_at IS NULL");
-    }
-    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    const sql = `
-      SELECT * FROM incidents
-      ${whereClause}
-      ORDER BY timestamp DESC
-      LIMIT ?
-    `;
-    const result = await this.db.query(sql, [...params, limit]);
-    return result.rows.map((row) => this.rowToIncident(row));
-  }
-  /**
-   * Resolve an incident
-   */
-  async resolveIncident(id, resolutionNotes) {
-    const resolvedAt = Date.now();
-    const result = await this.db.query(
-      `UPDATE incidents
-       SET resolved_at = ?, resolution_notes = ?
-       WHERE id = ?`,
-      [resolvedAt, resolutionNotes ?? null, id]
-    );
-    if (result.rowCount === 0) {
-      return null;
-    }
-    this.log("info", "Incident resolved", { id, resolvedAt });
-    const incident = await this.getIncident(id);
-    if (incident && platform.analytics) {
-      const durationMs = resolvedAt - incident.timestamp;
-      const durationMinutes = Math.floor(durationMs / 6e4);
-      platform.analytics.track("incident.resolved", {
-        incidentId: id,
-        type: incident.type,
-        severity: incident.severity,
-        durationMs,
-        durationMinutes,
-        hasResolutionNotes: !!resolutionNotes,
-        wasAnalyzed: !!incident.aiAnalysis
-      }).catch(() => {
-      });
-    }
-    return incident;
-  }
-  /**
-   * Delete an incident
-   */
-  async deleteIncident(id) {
-    const incident = await this.getIncident(id);
-    const result = await this.db.query("DELETE FROM incidents WHERE id = ?", [id]);
-    const deleted = result.rowCount > 0;
-    if (deleted) {
-      this.log("info", "Incident deleted", { id });
-      if (incident && platform.analytics) {
-        platform.analytics.track("incident.deleted", {
-          incidentId: id,
-          type: incident.type,
-          severity: incident.severity,
-          wasResolved: !!incident.resolvedAt,
-          wasAnalyzed: !!incident.aiAnalysis
-        }).catch(() => {
-        });
-      }
-    }
-    return deleted;
-  }
-  /**
-   * Get statistics about stored incidents
-   */
-  async getStats() {
-    const totalResult = await this.db.query(`
-      SELECT
-        COUNT(*) as total,
-        MIN(timestamp) as oldest,
-        MAX(timestamp) as newest
-      FROM incidents
-    `);
-    const { total, oldest, newest } = totalResult.rows[0];
-    const severityResult = await this.db.query("SELECT severity, COUNT(*) as count FROM incidents GROUP BY severity");
-    const bySeverity = {
-      critical: 0,
-      warning: 0,
-      info: 0
-    };
-    for (const row of severityResult.rows) {
-      bySeverity[row.severity] = row.count;
-    }
-    const typeResult = await this.db.query("SELECT type, COUNT(*) as count FROM incidents GROUP BY type");
-    const byType = {};
-    for (const row of typeResult.rows) {
-      byType[row.type] = row.count;
-    }
-    const resolvedResult = await this.db.query(`
-      SELECT
-        SUM(CASE WHEN resolved_at IS NOT NULL THEN 1 ELSE 0 END) as resolved,
-        SUM(CASE WHEN resolved_at IS NULL THEN 1 ELSE 0 END) as unresolved
-      FROM incidents
-    `);
-    const { resolved, unresolved } = resolvedResult.rows[0];
-    return {
-      total,
-      bySeverity,
-      byType,
-      resolved: resolved ?? 0,
-      unresolved: unresolved ?? 0,
-      oldestTimestamp: oldest,
-      newestTimestamp: newest
-    };
-  }
-  /**
-   * Clear all incidents (admin function)
-   */
-  async clearAll() {
-    await this.db.query("DELETE FROM incidents");
-    this.log("warn", "All incidents cleared");
-  }
-  /**
-   * Update AI analysis for an incident
-   */
-  async updateAIAnalysis(id, analysis) {
-    await this.db.query(
-      `UPDATE incidents
-       SET ai_analysis = ?, ai_analyzed_at = ?
-       WHERE id = ?`,
-      [JSON.stringify(analysis), Date.now(), id]
-    );
-    this.log("debug", "AI analysis updated", { id });
-  }
-  /**
-   * Convert database row to Incident object
-   * @private
-   */
-  rowToIncident(row) {
-    const affectedServices = row.affected_services ? JSON.parse(row.affected_services) : void 0;
-    const metadata = row.metadata ? JSON.parse(row.metadata) : void 0;
-    const aiAnalysis = row.ai_analysis ? JSON.parse(row.ai_analysis) : void 0;
-    const relatedData = row.related_logs_sample || row.related_metrics || row.timeline ? {
-      logs: row.related_logs_sample ? JSON.parse(row.related_logs_sample) : void 0,
-      metrics: row.related_metrics ? JSON.parse(row.related_metrics) : void 0,
-      timeline: row.timeline ? JSON.parse(row.timeline) : void 0
-    } : void 0;
-    return {
-      id: row.id,
-      type: row.type,
-      severity: row.severity,
-      title: row.title,
-      details: row.details,
-      timestamp: row.timestamp,
-      resolvedAt: row.resolved_at ?? void 0,
-      resolutionNotes: row.resolution_notes ?? void 0,
-      affectedServices,
-      metadata,
-      relatedData,
-      aiAnalysis,
-      aiAnalyzedAt: row.ai_analyzed_at ?? void 0
-    };
-  }
-  log(level, message, meta) {
-    if (level === "debug" && !this.config.debug) {
-      return;
-    }
-    if (this.logger[level]) {
-      this.logger[level](`[IncidentStorage] ${message}`, meta);
-    } else {
-      console.log(`[IncidentStorage] [${level}] ${message}`, meta);
-    }
-  }
-};
-var DEFAULT_THRESHOLDS = {
-  errorRateWarning: 5,
-  errorRateCritical: 10,
-  latencyP99Warning: 2e3,
-  latencyP99Critical: 5e3,
-  latencyP95Warning: 1e3,
-  minRequestsForDetection: 10,
-  pluginErrorRateWarning: 10,
-  pluginErrorRateCritical: 25
-};
-var DEFAULT_CONFIG4 = {
-  intervalMs: 3e4,
-  // 30 seconds
-  thresholds: DEFAULT_THRESHOLDS,
-  cooldownMs: 5 * 60 * 1e3,
-  // 5 minutes
-  debug: false
-};
-var IncidentDetector = class {
-  incidentStorage;
-  config;
-  logger;
-  intervalHandle = null;
-  recentIncidents = [];
-  isRunning = false;
-  // Metrics history for "before" comparison (last 10 snapshots)
-  metricsHistory = [];
-  constructor(incidentStorage, config = {}, logger = console) {
-    this.incidentStorage = incidentStorage;
-    this.config = {
-      ...DEFAULT_CONFIG4,
-      ...config,
-      thresholds: { ...DEFAULT_THRESHOLDS, ...config.thresholds }
-    };
-    this.logger = logger;
-  }
-  /**
-   * Start automatic detection
-   */
-  start() {
-    if (this.isRunning) {
-      this.log("warn", "Detector already running");
-      return;
-    }
-    this.isRunning = true;
-    this.log("info", "Starting incident detector", {
-      intervalMs: this.config.intervalMs,
-      thresholds: this.config.thresholds
-    });
-    this.runDetection().catch((err) => {
-      this.log("error", "Initial detection failed", { error: err.message });
-    });
-    this.intervalHandle = setInterval(() => {
-      this.runDetection().catch((err) => {
-        this.log("error", "Detection cycle failed", { error: err.message });
-      });
-    }, this.config.intervalMs);
-  }
-  /**
-   * Stop automatic detection
-   */
-  stop() {
-    if (this.intervalHandle) {
-      clearInterval(this.intervalHandle);
-      this.intervalHandle = null;
-    }
-    this.isRunning = false;
-    this.log("info", "Incident detector stopped");
-  }
-  /**
-   * Run a single detection cycle
-   */
-  async runDetection() {
-    const metrics = metricsCollector.getMetrics();
-    const now = Date.now();
-    const totalErrors = (metrics.requests.clientErrors ?? 0) + (metrics.requests.serverErrors ?? 0);
-    const errorRate = metrics.requests.total > 0 ? totalErrors / metrics.requests.total * 100 : 0;
-    this.metricsHistory.push({
-      timestamp: now,
-      errorRate,
-      avgLatency: metrics.latency.average ?? 0,
-      totalRequests: metrics.requests.total
-    });
-    if (this.metricsHistory.length > 10) {
-      this.metricsHistory.shift();
-    }
-    this.recentIncidents = this.recentIncidents.filter(
-      (ri) => now - ri.timestamp < this.config.cooldownMs
-    );
-    if (metrics.requests.total < this.config.thresholds.minRequestsForDetection) {
-      this.log("debug", "Not enough requests for detection", {
-        total: metrics.requests.total,
-        min: this.config.thresholds.minRequestsForDetection
-      });
-      return;
-    }
-    await this.detectErrorRate(metrics, now);
-    await this.detectLatencyIssues(metrics, now);
-    await this.detectPluginFailures(metrics, now);
-    this.log("debug", "Detection cycle complete", {
-      recentIncidentsCount: this.recentIncidents.length
-    });
-  }
-  /**
-   * Detect high error rate
-   */
-  async detectErrorRate(metrics, now) {
-    const totalErrors = (metrics.requests.clientErrors ?? 0) + (metrics.requests.serverErrors ?? 0);
-    const errorRate = metrics.requests.total > 0 ? totalErrors / metrics.requests.total * 100 : 0;
-    const key = "error_rate";
-    if (this.isInCooldown(key)) {
-      return;
-    }
-    let severity = null;
-    let title = "";
-    let details = "";
-    if (errorRate >= this.config.thresholds.errorRateCritical) {
-      severity = "critical";
-      title = `Critical Error Rate: ${errorRate.toFixed(1)}%`;
-      details = `Error rate has exceeded critical threshold of ${this.config.thresholds.errorRateCritical}%. Current: ${errorRate.toFixed(2)}% (${totalErrors}/${metrics.requests.total} requests). Client errors: ${metrics.requests.clientErrors ?? 0}, Server errors: ${metrics.requests.serverErrors ?? 0}.`;
-    } else if (errorRate >= this.config.thresholds.errorRateWarning) {
-      severity = "warning";
-      title = `High Error Rate: ${errorRate.toFixed(1)}%`;
-      details = `Error rate has exceeded warning threshold of ${this.config.thresholds.errorRateWarning}%. Current: ${errorRate.toFixed(2)}% (${totalErrors}/${metrics.requests.total} requests).`;
-    }
-    if (severity) {
-      await this.createIncident({
-        type: "error_rate",
-        severity,
-        title,
-        details,
-        metadata: {
-          errorRate,
-          totalRequests: metrics.requests.total,
-          clientErrors: metrics.requests.clientErrors,
-          serverErrors: metrics.requests.serverErrors,
-          threshold: severity === "critical" ? this.config.thresholds.errorRateCritical : this.config.thresholds.errorRateWarning
-        }
-      }, key, now);
-    }
-  }
-  /**
-   * Detect latency spikes
-   */
-  async detectLatencyIssues(metrics, now) {
-    const avgLatency = metrics.latency.average ?? 0;
-    let p99 = avgLatency * 3;
-    let p95 = avgLatency * 2;
-    if (metrics.latency.histogram && metrics.latency.histogram.length > 0) {
-      const sorted = [...metrics.latency.histogram].sort((a, b) => b.max - a.max);
-      if (sorted.length > 0) {
-        p99 = sorted[0]?.max ?? p99;
-        p95 = sorted[Math.floor(sorted.length * 0.05)]?.max ?? p95;
-      }
-    }
-    const keyP99 = "latency_p99";
-    const keyP95 = "latency_p95";
-    if (!this.isInCooldown(keyP99)) {
-      let severity = null;
-      let title = "";
-      let details = "";
-      if (p99 >= this.config.thresholds.latencyP99Critical) {
-        severity = "critical";
-        title = `Critical P99 Latency: ${p99.toFixed(0)}ms`;
-        details = `P99 latency has exceeded critical threshold of ${this.config.thresholds.latencyP99Critical}ms. Current P99: ${p99.toFixed(0)}ms, Average: ${avgLatency.toFixed(0)}ms. This indicates severe performance degradation affecting tail latencies.`;
-      } else if (p99 >= this.config.thresholds.latencyP99Warning) {
-        severity = "warning";
-        title = `High P99 Latency: ${p99.toFixed(0)}ms`;
-        details = `P99 latency has exceeded warning threshold of ${this.config.thresholds.latencyP99Warning}ms. Current P99: ${p99.toFixed(0)}ms, Average: ${avgLatency.toFixed(0)}ms.`;
-      }
-      if (severity) {
-        await this.createIncident({
-          type: "latency_spike",
-          severity,
-          title,
-          details,
-          metadata: {
-            p99,
-            p95,
-            average: avgLatency,
-            threshold: severity === "critical" ? this.config.thresholds.latencyP99Critical : this.config.thresholds.latencyP99Warning
-          }
-        }, keyP99, now);
-      }
-    }
-    if (!this.isInCooldown(keyP95) && p95 >= this.config.thresholds.latencyP95Warning) {
-      await this.createIncident({
-        type: "latency_spike",
-        severity: "warning",
-        title: `Elevated P95 Latency: ${p95.toFixed(0)}ms`,
-        details: `P95 latency has exceeded threshold of ${this.config.thresholds.latencyP95Warning}ms. Current P95: ${p95.toFixed(0)}ms. Consider investigating slow endpoints.`,
-        metadata: {
-          p95,
-          average: avgLatency,
-          threshold: this.config.thresholds.latencyP95Warning
-        }
-      }, keyP95, now);
-    }
-  }
-  /**
-   * Detect plugin failures
-   */
-  async detectPluginFailures(metrics, now) {
-    if (!metrics.perPlugin || !Array.isArray(metrics.perPlugin)) {
-      return;
-    }
-    for (const plugin of metrics.perPlugin) {
-      if (!plugin.pluginId || plugin.requests < 5) {
-        continue;
-      }
-      const errorRate = plugin.requests > 0 ? (plugin.errors ?? 0) / plugin.requests * 100 : 0;
-      const key = `plugin:${plugin.pluginId}`;
-      if (this.isInCooldown(key)) {
-        continue;
-      }
-      let severity = null;
-      let title = "";
-      let details = "";
-      if (errorRate >= this.config.thresholds.pluginErrorRateCritical) {
-        severity = "critical";
-        title = `Plugin Failure: ${plugin.pluginId}`;
-        details = `Plugin ${plugin.pluginId} has critical error rate of ${errorRate.toFixed(1)}% (${plugin.errors ?? 0}/${plugin.requests} requests). This exceeds the critical threshold of ${this.config.thresholds.pluginErrorRateCritical}%.`;
-      } else if (errorRate >= this.config.thresholds.pluginErrorRateWarning) {
-        severity = "warning";
-        title = `Plugin Issues: ${plugin.pluginId}`;
-        details = `Plugin ${plugin.pluginId} has elevated error rate of ${errorRate.toFixed(1)}% (${plugin.errors ?? 0}/${plugin.requests} requests).`;
-      }
-      if (severity) {
-        await this.createIncident({
-          type: "plugin_failure",
-          severity,
-          title,
-          details,
-          affectedServices: [plugin.pluginId],
-          metadata: {
-            pluginId: plugin.pluginId,
-            errorRate,
-            requests: plugin.requests,
-            errors: plugin.errors,
-            avgLatency: plugin.latency?.average
-          }
-        }, key, now);
-      }
-    }
-  }
-  /**
-   * Check if incident key is in cooldown
-   */
-  isInCooldown(key) {
-    return this.recentIncidents.some((ri) => ri.key === key);
-  }
-  /**
-   * Gather related data (logs, metrics, timeline) for incident
-   * @private
-   */
-  async gatherRelatedData(incidentType, timeWindow = 5 * 60 * 1e3) {
-    const now = Date.now();
-    const from = now - timeWindow;
-    const relatedData = {
-      timeline: []
-    };
-    try {
-      const [errorLogsResult, fatalLogsResult] = await Promise.all([
-        platform.logs.query({ level: "error", from, to: now }, { limit: 50 }),
-        platform.logs.query({ level: "fatal", from, to: now }, { limit: 50 })
-      ]);
-      const allErrorLogs = [...errorLogsResult.logs, ...fatalLogsResult.logs];
-      if (allErrorLogs.length > 0) {
-        allErrorLogs.sort((a, b) => b.timestamp - a.timestamp);
-        const uniqueErrors = /* @__PURE__ */ new Set();
-        const endpointErrorCount = /* @__PURE__ */ new Map();
-        for (const log of allErrorLogs) {
-          let errorMsg = typeof log.message === "string" ? log.message : JSON.stringify(log.message);
-          if (log.err) {
-            const err = log.err;
-            const stack = err.stack ? `
-${err.stack.split("\n").slice(0, 3).join("\n")}` : "";
-            errorMsg = `${err.message || errorMsg}${stack}`;
-            if (log.plugin) {
-              errorMsg = `[${log.plugin}] ${errorMsg}`;
-            }
-            if (log.command) {
-              errorMsg += `
-Command: ${log.command}`;
-            }
-          }
-          if (errorMsg && uniqueErrors.size < 5) {
-            uniqueErrors.add(errorMsg.substring(0, 500));
-          }
-          const endpoint = log.endpoint || log.url || "unknown";
-          const existing = endpointErrorCount.get(endpoint);
-          if (existing) {
-            existing.count++;
-          } else {
-            endpointErrorCount.set(endpoint, {
-              count: 1,
-              sample: errorMsg.substring(0, 200)
-            });
-          }
-        }
-        const topEndpoints = Array.from(endpointErrorCount.entries()).sort((a, b) => b[1].count - a[1].count).slice(0, 5).map(([endpoint, data]) => ({
-          endpoint,
-          count: data.count,
-          sample: data.sample
-        }));
-        relatedData.logs = {
-          errorCount: allErrorLogs.filter((l) => l.level === "error").length,
-          warnCount: 0,
-          // Could query warnings separately if needed
-          timeRange: [from, now],
-          sampleErrors: Array.from(uniqueErrors),
-          topEndpoints: topEndpoints.length > 0 ? topEndpoints : void 0
-        };
-        for (const log of allErrorLogs.slice(0, 10)) {
-          const msg = typeof log.message === "string" ? log.message : "Error occurred";
-          const plugin = log.plugin ? `[${log.plugin}] ` : "";
-          relatedData.timeline.push({
-            timestamp: log.timestamp,
-            event: `${plugin}${msg.substring(0, 100)}`,
-            source: "logs"
-          });
-        }
-      }
-    } catch (error) {
-      this.log("warn", "Failed to gather related logs", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-    const currentMetrics = metricsCollector.getMetrics();
-    const duringMetrics = {
-      errorRate: currentMetrics.requests.total > 0 ? (currentMetrics.requests.clientErrors + currentMetrics.requests.serverErrors) / currentMetrics.requests.total * 100 : 0,
-      avgLatency: currentMetrics.latency.average ?? 0,
-      totalRequests: currentMetrics.requests.total,
-      totalErrors: currentMetrics.requests.clientErrors + currentMetrics.requests.serverErrors
-    };
-    let beforeMetrics;
-    if (this.metricsHistory.length >= 2) {
-      const beforeSnapshots = this.metricsHistory.slice(0, -1);
-      if (beforeSnapshots.length > 0) {
-        const avgErrorRate = beforeSnapshots.reduce((sum, s) => sum + s.errorRate, 0) / beforeSnapshots.length;
-        const avgLatency = beforeSnapshots.reduce((sum, s) => sum + s.avgLatency, 0) / beforeSnapshots.length;
-        const avgRequests = beforeSnapshots.reduce((sum, s) => sum + s.totalRequests, 0) / beforeSnapshots.length;
-        beforeMetrics = {
-          errorRate: avgErrorRate,
-          avgLatency,
-          totalRequests: avgRequests
-        };
-        this.log("debug", "Calculated before metrics", {
-          before: beforeMetrics,
-          during: duringMetrics,
-          snapshotsUsed: beforeSnapshots.length
-        });
-      }
-    }
-    let topSlowest;
-    let affectedEndpoints;
-    if (incidentType === "latency_spike") {
-      const histogram = currentMetrics.latency.histogram;
-      if (histogram && histogram.length > 0) {
-        const slowestRoutes = histogram.filter((h) => h.max > 100).sort((a, b) => b.max - a.max).slice(0, 10);
-        topSlowest = slowestRoutes.map((h) => {
-          const [method, ...pathParts] = h.route.split(" ");
-          const endpoint = pathParts.join(" ");
-          const statusCodes = Object.keys(h.byStatus);
-          const mostCommonStatus = statusCodes.length > 0 ? parseInt(statusCodes[0], 10) : void 0;
-          return {
-            endpoint,
-            method: method || "GET",
-            durationMs: Math.round(h.max),
-            statusCode: mostCommonStatus
-          };
-        });
-        affectedEndpoints = [...new Set(slowestRoutes.map((h) => h.route))];
-        this.log("debug", "Collected slow requests for latency incident", {
-          topSlowestCount: topSlowest.length,
-          affectedEndpointsCount: affectedEndpoints.length
-        });
-      }
-    }
-    relatedData.metrics = {
-      before: beforeMetrics,
-      during: duringMetrics,
-      topSlowest,
-      affectedEndpoints
-    };
-    relatedData.timeline.unshift({
-      timestamp: now,
-      event: `Incident detected: ${incidentType}`,
-      source: "detector"
-    });
-    relatedData.timeline.sort((a, b) => b.timestamp - a.timestamp);
-    return relatedData;
-  }
-  /**
-   * Create incident and track it
-   */
-  async createIncident(payload, key, timestamp) {
-    try {
-      const relatedData = await this.gatherRelatedData(payload.type);
-      const enrichedPayload = {
-        ...payload,
-        relatedData
-      };
-      const incident = await this.incidentStorage.createIncident(enrichedPayload);
-      this.recentIncidents.push({
-        type: payload.type,
-        key,
-        timestamp
-      });
-      this.log("info", "Auto-created incident with context", {
-        id: incident.id,
-        type: incident.type,
-        severity: incident.severity,
-        title: incident.title,
-        errorLogsCount: relatedData.logs?.errorCount ?? 0,
-        timelineEventsCount: relatedData.timeline?.length ?? 0
-      });
-      if (platform.analytics) {
-        platform.analytics.track("incident.created", {
-          incidentId: incident.id,
-          type: incident.type,
-          severity: incident.severity,
-          source: "auto-detector",
-          errorLogsCount: relatedData.logs?.errorCount ?? 0,
-          timelineEventsCount: relatedData.timeline?.length ?? 0,
-          hasBeforeMetrics: !!relatedData.metrics?.before,
-          affectedServicesCount: payload.affectedServices?.length ?? 0
-        }).catch(() => {
-        });
-      }
-    } catch (error) {
-      this.log("error", "Failed to create incident", {
-        key,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  /**
-   * Get current detector status
-   */
-  getStatus() {
-    return {
-      running: this.isRunning,
-      config: this.config,
-      recentIncidentsCount: this.recentIncidents.length
-    };
-  }
-  /**
-   * Update thresholds at runtime
-   */
-  updateThresholds(thresholds) {
-    this.config.thresholds = { ...this.config.thresholds, ...thresholds };
-    this.log("info", "Thresholds updated", { thresholds: this.config.thresholds });
-  }
-  log(level, message, meta) {
-    if (level === "debug" && !this.config.debug) {
-      return;
-    }
-    const prefix = "[IncidentDetector]";
-    if (this.logger[level]) {
-      if (meta) {
-        this.logger[level]({ ...meta }, `${prefix} ${message}`);
-      } else {
-        this.logger[level](`${prefix} ${message}`);
-      }
-    } else {
-      console.log(`${prefix} [${level}] ${message}`, meta ?? "");
-    }
-  }
-};
 
 // src/routes/index.ts
 function normalizeBasePath2(basePath) {
@@ -7459,71 +5835,7 @@ async function registerRoutes(server, config, repoRoot, registry) {
     historicalCollector.stop();
     platform.logger.info("Historical metrics collector stopped");
   });
-  let incidentStorage;
-  const db = platform.getAdapter("db");
-  if (db) {
-    try {
-      const { readFileSync: readFileSync2 } = await import('fs');
-      const { fileURLToPath } = await import('url');
-      const { dirname: dirname2, join: join3 } = await import('path');
-      const __filename = fileURLToPath(import.meta.url);
-      const __dirname = dirname2(__filename);
-      const schemaPath = join3(__dirname, "..", "services", "incident-schema.sql");
-      const schema = readFileSync2(schemaPath, "utf-8");
-      if ("exec" in db && typeof db.exec === "function") {
-        await db.exec(schema);
-      } else {
-        const statements = schema.split(";").map((s) => s.trim()).filter((s) => s.length > 0 && !s.startsWith("--"));
-        for (const statement of statements) {
-          if (statement) {
-            await db.query(statement);
-          }
-        }
-      }
-      platform.logger.info("Incidents schema initialized");
-      incidentStorage = new IncidentStorage(
-        db,
-        { debug: process.env.NODE_ENV !== "production" },
-        platformServices.logger
-      );
-      platform.logger.info("Incident storage initialized");
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      platform.logger.warn("Failed to initialize incident storage, continuing without it", { error: error.message });
-    }
-  } else {
-    platform.logger.warn("Database adapter (db) not configured \u2014 incident storage disabled. Configure db adapter in kb.config.json to enable.");
-  }
-  if (incidentStorage) {
-    const incidentDetector = new IncidentDetector(
-      incidentStorage,
-      {
-        intervalMs: 3e4,
-        // Check every 30 seconds
-        cooldownMs: 5 * 60 * 1e3,
-        // 5 minute cooldown between same incidents
-        debug: process.env.NODE_ENV !== "production",
-        thresholds: {
-          errorRateWarning: 5,
-          errorRateCritical: 10,
-          latencyP99Warning: 2e3,
-          latencyP99Critical: 5e3,
-          latencyP95Warning: 1e3,
-          minRequestsForDetection: 10,
-          pluginErrorRateWarning: 10,
-          pluginErrorRateCritical: 25
-        }
-      },
-      platformServices.logger
-    );
-    incidentDetector.start();
-    platform.logger.info("Incident detector started");
-    server.addHook("onClose", async () => {
-      incidentDetector.stop();
-      platform.logger.info("Incident detector stopped");
-    });
-  }
-  await registerObservabilityRoutes(server, config, repoRoot, historicalCollector, incidentStorage, platformServices);
+  await registerObservabilityRoutes(server, config, repoRoot, historicalCollector, platformServices);
   await registerAnalyticsRoutes(server, config);
   await registerAdaptersRoutes(server, config);
   await registerLogRoutes(server);
@@ -7614,6 +5926,9 @@ function registerEnvelopeMiddleware(server, config) {
     if (parsedPayload && typeof parsedPayload === "object" && "ok" in parsedPayload) {
       return payload;
     }
+    if (reply.getHeader("x-openapi-spec")) {
+      return payload;
+    }
     let dataToWrap = parsedPayload;
     if (parsedPayload === null || parsedPayload === void 0) {
       dataToWrap = null;