@kb-labs/rest-api-app 2.94.0 → 2.96.0

package/dist/index.js

@@ -3,7 +3,7 @@ import Fastify from 'fastify';
 import { loadEnvFromRoot, createServiceBootstrap, platform, getPlatformRoot } from '@kb-labs/core-runtime';
 import { EventEmitter } from 'events';
 import { performance, monitorEventLoopDelay } from 'perf_hooks';
-import { OperationMetricsTracker, registerOpenAPI, createCorrelatedLogger, createServiceObservabilityDescribe, createServiceObservabilityHealth } from '@kb-labs/shared-http';
+import { OperationMetricsTracker, getListenOptions, registerOpenAPI, createCorrelatedLogger, createServiceObservabilityDescribe, createServiceObservabilityHealth } from '@kb-labs/shared-http';
 import { Registry, Histogram, Counter, Gauge } from 'prom-client';
 import * as os from 'os';
 import { hostname } from 'os';
@@ -13,14 +13,15 @@ import { createRegistry, mergeOpenAPISpecs } from '@kb-labs/core-registry';
 import { validateManifest } from '@kb-labs/plugin-contracts';
 import { mountRoutes } from '@kb-labs/plugin-execution/http';
 import { mountWebSocketChannels } from '@kb-labs/plugin-execution';
+import { InProcessBackend } from '@kb-labs/plugin-execution-factory';
 import { logDiagnosticEvent } from '@kb-labs/core-platform';
-import * as path2 from 'path';
+import * as path from 'path';
 import * as fs from 'fs/promises';
 import { resolveWorkspaceRoot } from '@kb-labs/core-workspace';
 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 { errorEnvelopeSchema, ErrorResponseSchema, JobsListResponseSchema, ListJobsQuerySchema, JobStatsResponseSchema, JobResponseSchema, JobActionResponseSchema } from '@kb-labs/rest-api-contracts';
 import { readKbConfig } from '@kb-labs/core-config';
 import { AdapterNameSchema } from '@kb-labs/gateway-contracts';
 import fastifyCors from '@fastify/cors';
@@ -30,6 +31,7 @@ import { randomUUID, createHash } from 'crypto';
 import { TenantRateLimiter, getDefaultTenantTier } from '@kb-labs/core-tenant';
 import { promises, existsSync, readFileSync } from 'fs';
 import { findRepoRoot } from '@kb-labs/core-sys';
+import { makeAssemblyHook } from '@kb-labs/plugin-runtime';
 
 // src/bootstrap.ts
 var EventHub = class {
@@ -769,7 +771,7 @@ function updateLatencyHistogram(histogram, bucket, durationMs, statusCode) {
   stats.byStatus[statusKey] = (stats.byStatus[statusKey] || 0) + 1;
 }
 
-// src/utils/sse-auth.ts
+// src/routes/sse-auth.ts
 function extractTokenFromHeader(headerValue, headerName) {
   if (typeof headerValue === "string") {
     if (headerName === "authorization") {
@@ -915,7 +917,7 @@ async function registerEventRoutes(server, basePath, registry, readiness, eventH
   });
 }
 
-// src/utils/path-helpers.ts
+// src/routes/path-helpers.ts
 function normalizeBasePath(basePath) {
   if (!basePath || basePath === "/") {
     return "";
@@ -1073,6 +1075,323 @@ function getLatestSystemMetrics() {
   return latestSystemMetricsSnapshot;
 }
 
+// src/daemon/metrics/historical-metrics.ts
+var DEFAULT_CONFIG = {
+  intervalMs: 5e3,
+  maxPoints: {
+    "1m": 12,
+    "5m": 60,
+    "10m": 120,
+    "30m": 360,
+    "1h": 720
+  },
+  debug: false
+};
+var HistoricalMetricsCollector = class {
+  cache;
+  config;
+  intervalHandle = null;
+  logger;
+  startTimeMs = Date.now();
+  constructor(cache, config = {}, logger = console) {
+    this.cache = cache;
+    this.config = { ...DEFAULT_CONFIG, ...config, maxPoints: { ...DEFAULT_CONFIG.maxPoints, ...config.maxPoints } };
+    this.logger = logger;
+  }
+  /**
+   * Start background collection
+   */
+  start() {
+    if (this.intervalHandle) {
+      this.log("warn", "Historical metrics collector already started");
+      return;
+    }
+    this.log("info", "Starting historical metrics collector", {
+      intervalMs: this.config.intervalMs
+    });
+    this.collect().catch((err) => {
+      this.log("error", "Failed to collect initial metrics", { err });
+    });
+    this.intervalHandle = setInterval(() => {
+      this.collect().catch((err) => {
+        this.log("error", "Failed to collect metrics", { err });
+      });
+    }, this.config.intervalMs);
+  }
+  /**
+   * Stop background collection
+   */
+  stop() {
+    if (this.intervalHandle) {
+      clearInterval(this.intervalHandle);
+      this.intervalHandle = null;
+      this.log("info", "Historical metrics collector stopped");
+    }
+  }
+  /**
+   * Collect current metrics snapshot and store in cache
+   */
+  async collect() {
+    const now = Date.now();
+    const metrics = metricsCollector.getMetrics();
+    const snapshot = {
+      timestamp: now,
+      requests: {
+        total: metrics.requests.total,
+        success: metrics.requests.success ?? 0,
+        clientErrors: metrics.requests.clientErrors ?? 0,
+        serverErrors: metrics.requests.serverErrors ?? 0
+      },
+      latency: {
+        average: metrics.latency.average,
+        min: metrics.latency.min === Infinity ? 0 : metrics.latency.min,
+        max: metrics.latency.max
+      },
+      uptime: (now - metrics.timestamps.startTime) / 1e3,
+      perPlugin: metrics.perPlugin.map((p) => ({
+        pluginId: p.pluginId,
+        requests: p.total,
+        errors: Object.values(p.statuses).filter((_, idx) => Object.keys(p.statuses)[idx]?.startsWith("4") || Object.keys(p.statuses)[idx]?.startsWith("5")).reduce((sum, count) => sum + count, 0),
+        avgLatency: p.total > 0 ? p.totalDuration / p.total : 0
+      }))
+    };
+    await Promise.all([
+      this.appendToTimeSeries("1m", snapshot, 2 * 60 * 1e3),
+      // TTL: 2 minutes
+      this.appendToTimeSeries("5m", snapshot, 10 * 60 * 1e3),
+      // TTL: 10 minutes
+      this.appendToTimeSeries("10m", snapshot, 20 * 60 * 1e3),
+      // TTL: 20 minutes
+      this.appendToTimeSeries("30m", snapshot, 60 * 60 * 1e3),
+      // TTL: 1 hour
+      this.appendToTimeSeries("1h", snapshot, 2 * 60 * 60 * 1e3)
+      // TTL: 2 hours
+    ]);
+    if (now % 6e4 < this.config.intervalMs) {
+      await this.updateHeatmapAggregation(snapshot).catch((err) => {
+        this.log("error", "Failed to update heatmap", { err });
+      });
+    }
+    this.log("debug", "Metrics snapshot collected", {
+      timestamp: new Date(now).toISOString(),
+      requests: snapshot.requests.total,
+      latency: snapshot.latency.average.toFixed(2)
+    });
+  }
+  /**
+   * Append snapshot to time series bucket
+   */
+  async appendToTimeSeries(range, snapshot, ttlMs) {
+    const key = `metrics:history:${range}`;
+    const maxPoints = this.config.maxPoints[range] ?? 120;
+    let timeSeries = await this.cache.get(key);
+    if (!timeSeries || !Array.isArray(timeSeries)) {
+      timeSeries = [];
+    }
+    timeSeries.push(snapshot);
+    if (timeSeries.length > maxPoints) {
+      timeSeries = timeSeries.slice(timeSeries.length - maxPoints);
+    }
+    await this.cache.set(key, timeSeries, ttlMs);
+  }
+  /**
+   * Update heatmap aggregation for weekly patterns
+   */
+  async updateHeatmapAggregation(snapshot) {
+    const key = "metrics:heatmap:7d";
+    const ttlMs = 24 * 60 * 60 * 1e3;
+    let heatmapData = await this.cache.get(key);
+    if (!heatmapData || typeof heatmapData !== "object") {
+      heatmapData = { latency: [], errors: [], requests: [] };
+    }
+    const date = new Date(snapshot.timestamp);
+    const day = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"][date.getDay()];
+    const hour = date.getHours();
+    for (const metricType of ["latency", "errors", "requests"]) {
+      let cells = heatmapData[metricType] || [];
+      const cellIndex = cells.findIndex((c) => c.day === day && c.hour === hour);
+      let value = 0;
+      if (metricType === "latency") {
+        value = snapshot.latency.average;
+      } else if (metricType === "errors") {
+        value = snapshot.requests.clientErrors + snapshot.requests.serverErrors;
+      } else {
+        value = snapshot.requests.total;
+      }
+      if (cellIndex >= 0 && cells[cellIndex]) {
+        cells[cellIndex].value = cells[cellIndex].value * 0.9 + value * 0.1;
+      } else {
+        cells.push({ day, hour, value });
+      }
+      if (cells.length > 168) {
+        cells = cells.slice(cells.length - 168);
+      }
+      heatmapData[metricType] = cells;
+    }
+    await this.cache.set(key, heatmapData, ttlMs);
+  }
+  /**
+   * Query historical time-series data
+   */
+  async queryHistory(params) {
+    const key = `metrics:history:${params.range}`;
+    const timeSeries = await this.cache.get(key);
+    if (!timeSeries || !Array.isArray(timeSeries)) {
+      return [];
+    }
+    const dataPoints = timeSeries.map((snapshot) => {
+      let value = 0;
+      switch (params.metric) {
+        case "requests":
+          value = snapshot.requests.total;
+          break;
+        case "errors":
+          value = snapshot.requests.clientErrors + snapshot.requests.serverErrors;
+          break;
+        case "latency":
+          value = snapshot.latency.average;
+          break;
+        case "uptime":
+          value = snapshot.uptime;
+          break;
+      }
+      return {
+        timestamp: snapshot.timestamp,
+        value
+      };
+    });
+    if (params.interval && params.interval !== "5s") {
+      return this.aggregateByInterval(dataPoints, params.interval);
+    }
+    return dataPoints;
+  }
+  /**
+   * Query heatmap data
+   */
+  async queryHeatmap(params) {
+    const key = "metrics:heatmap:7d";
+    const heatmapData = await this.cache.get(key);
+    if (!heatmapData || typeof heatmapData !== "object") {
+      return this.generateEmptyHeatmap();
+    }
+    const cells = heatmapData[params.metric] || [];
+    if (cells.length === 0) {
+      return this.generateEmptyHeatmap();
+    }
+    return this.fillHeatmapGaps(cells);
+  }
+  /**
+   * Generate empty heatmap structure (7 days × 24 hours)
+   */
+  generateEmptyHeatmap() {
+    const days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+    const cells = [];
+    for (const day of days) {
+      for (let hour = 0; hour < 24; hour++) {
+        cells.push({ day, hour, value: 0 });
+      }
+    }
+    return cells;
+  }
+  /**
+   * Fill gaps in heatmap data (missing day/hour combinations)
+   */
+  fillHeatmapGaps(cells) {
+    const days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+    const cellMap = /* @__PURE__ */ new Map();
+    for (const cell of cells) {
+      const key = `${cell.day}:${cell.hour}`;
+      cellMap.set(key, cell.value);
+    }
+    const complete = [];
+    for (const day of days) {
+      for (let hour = 0; hour < 24; hour++) {
+        const key = `${day}:${hour}`;
+        complete.push({
+          day,
+          hour,
+          value: cellMap.get(key) ?? 0
+        });
+      }
+    }
+    return complete;
+  }
+  /**
+   * Aggregate data points by interval
+   */
+  aggregateByInterval(dataPoints, interval) {
+    if (dataPoints.length === 0) {
+      return [];
+    }
+    const intervalMs = interval === "1m" ? 60 * 1e3 : 5 * 60 * 1e3;
+    const aggregated = [];
+    let bucket = [];
+    let bucketStart = Math.floor(dataPoints[0].timestamp / intervalMs) * intervalMs;
+    for (const point of dataPoints) {
+      const pointBucket = Math.floor(point.timestamp / intervalMs) * intervalMs;
+      if (pointBucket === bucketStart) {
+        bucket.push(point);
+      } else {
+        if (bucket.length > 0) {
+          const avgValue = bucket.reduce((sum, p) => sum + p.value, 0) / bucket.length;
+          aggregated.push({
+            timestamp: bucketStart + intervalMs / 2,
+            // midpoint
+            value: avgValue
+          });
+        }
+        bucket = [point];
+        bucketStart = pointBucket;
+      }
+    }
+    if (bucket.length > 0) {
+      const avgValue = bucket.reduce((sum, p) => sum + p.value, 0) / bucket.length;
+      aggregated.push({
+        timestamp: bucketStart + intervalMs / 2,
+        value: avgValue
+      });
+    }
+    return aggregated;
+  }
+  /**
+   * Get collector statistics
+   */
+  async getStats() {
+    const stats = {
+      running: this.intervalHandle !== null,
+      uptimeSeconds: (Date.now() - this.startTimeMs) / 1e3,
+      timeSeries: {},
+      heatmap: { cells: 0, metrics: [] }
+    };
+    for (const range of ["1m", "5m", "10m", "30m", "1h"]) {
+      const key = `metrics:history:${range}`;
+      const timeSeries = await this.cache.get(key);
+      if (timeSeries && Array.isArray(timeSeries)) {
+        stats.timeSeries[range] = {
+          points: timeSeries.length,
+          oldestTimestamp: timeSeries[0]?.timestamp ?? null,
+          newestTimestamp: timeSeries[timeSeries.length - 1]?.timestamp ?? null
+        };
+      } else {
+        stats.timeSeries[range] = { points: 0, oldestTimestamp: null, newestTimestamp: null };
+      }
+    }
+    const heatmapData = await this.cache.get("metrics:heatmap:7d");
+    if (heatmapData && typeof heatmapData === "object") {
+      const metrics = Object.keys(heatmapData);
+      const totalCells = metrics.reduce((sum, m) => sum + (heatmapData[m]?.length ?? 0), 0);
+      stats.heatmap = { cells: totalCells, metrics };
+    }
+    return stats;
+  }
+  log(level, message, meta) {
+    if (level === "debug" && !this.config.debug) {
+      return;
+    }
+    this.logger[level](`[HistoricalMetrics] ${message}`, meta);
+  }
+};
+
 // src/observability/service-contract.ts
 var REST_VERSION = "1.6.0" ;
 function resolveInstanceId() {
@@ -1727,6 +2046,7 @@ async function registerPluginRoutes(server, config, repoRoot, registry, readines
     }
     emitRegistrySnapshotDiagnostics(snapshot);
     const backend = platform.executionBackend;
+    const wsBackend = new InProcessBackend({ platform: platform });
     const mountableManifests = manifests.filter(
       (entry) => entry.manifest.rest?.routes && entry.manifest.rest.routes.length > 0 || entry.manifest.ws?.channels && entry.manifest.ws.channels.length > 0
     );
@@ -1741,8 +2061,8 @@ async function registerPluginRoutes(server, config, repoRoot, registry, readines
         for (const route of entry.manifest.rest.routes) {
           const handlerFile = route.handler.split("#")[0];
           if (handlerFile) {
-            const pluginDistRoot = path2.join(entry.pluginRoot, "dist");
-            const handlerPath = path2.resolve(pluginDistRoot, handlerFile);
+            const pluginDistRoot = path.join(entry.pluginRoot, "dist");
+            const handlerPath = path.resolve(pluginDistRoot, handlerFile);
             handlerChecks.push({
               key: `${entry.manifest.id}::${route.method} ${route.path}`,
               filePath: handlerPath
@@ -1778,7 +2098,7 @@ async function registerPluginRoutes(server, config, repoRoot, registry, readines
     const routeFailures = [];
     for (const entry of mountableManifests) {
       const { manifest, pluginRoot } = entry;
-      const pluginDistRoot = path2.join(pluginRoot, "dist");
+      const pluginDistRoot = path.join(pluginRoot, "dist");
       const restValidationErrors = [];
       if (manifest.rest?.routes) {
         for (const route of manifest.rest.routes) {
@@ -1931,7 +2251,7 @@ async function registerPluginRoutes(server, config, repoRoot, registry, readines
               channels: manifest.ws.channels.length
             });
             const wsResult = await mountWebSocketChannels(server, manifest, {
-              backend,
+              backend: wsBackend,
               pluginRoot: pluginDistRoot,
               workspaceRoot,
               basePath: wsBasePath,
@@ -2113,7 +2433,7 @@ async function registerPluginSnapshotRoutes(server, config, registry) {
         snapshot.manifests.map(async (entry) => {
           let buildTimestamp;
           try {
-            const distPath = path2.join(entry.pluginRoot, "dist");
+            const distPath = path.join(entry.pluginRoot, "dist");
             const stats = await fs.stat(distPath);
             buildTimestamp = stats.mtime.toISOString();
           } catch {
@@ -2162,6 +2482,62 @@ async function registerPluginSnapshotRoutes(server, config, registry) {
       });
     }
   });
+  server.get(`${basePath}/plugins/@:scope/:name/readme`, {
+    schema: { hide: true }
+  }, async (request, reply) => {
+    const { scope, name } = request.params;
+    if (!scope || !name) {
+      return reply.code(400).send({ error: "Invalid plugin identifier" });
+    }
+    const pluginId = `@${scope}/${name}`;
+    const snapshot = registry.snapshot();
+    const manifests = extractSnapshotManifests(snapshot);
+    const entry = manifests.find((e) => e.pluginId === pluginId);
+    if (!entry) {
+      return reply.code(404).send({ error: `Plugin not found: ${pluginId}` });
+    }
+    const readmePath = path.join(entry.pluginRoot, "README.md");
+    if (!readmePath.startsWith(entry.pluginRoot)) {
+      return reply.code(400).send({ error: "Invalid path" });
+    }
+    try {
+      const content = await fs.readFile(readmePath, "utf-8");
+      return reply.code(200).header("Content-Type", "text/plain; charset=utf-8").send(content);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return reply.code(404).send({ error: "README.md not found" });
+      }
+      return reply.code(500).send({ error: "Failed to read README.md" });
+    }
+  });
+  server.get(`${basePath}/plugins/@:scope/:name/changelog`, {
+    schema: { hide: true }
+  }, async (request, reply) => {
+    const { scope, name } = request.params;
+    if (!scope || !name) {
+      return reply.code(400).send({ error: "Invalid plugin identifier" });
+    }
+    const pluginId = `@${scope}/${name}`;
+    const snapshot = registry.snapshot();
+    const manifests = extractSnapshotManifests(snapshot);
+    const entry = manifests.find((e) => e.pluginId === pluginId);
+    if (!entry) {
+      return reply.code(404).send({ error: `Plugin not found: ${pluginId}` });
+    }
+    const changelogPath = path.join(entry.pluginRoot, "CHANGELOG.md");
+    if (!changelogPath.startsWith(entry.pluginRoot)) {
+      return reply.code(400).send({ error: "Invalid path" });
+    }
+    try {
+      const content = await fs.readFile(changelogPath, "utf-8");
+      return reply.code(200).header("Content-Type", "text/plain; charset=utf-8").send(content);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return reply.code(404).send({ error: "CHANGELOG.md not found" });
+      }
+      return reply.code(500).send({ error: "Failed to read CHANGELOG.md" });
+    }
+  });
   server.get(`${basePath}/studio/registry`, {
     schema: { tags: ["Studio"], summary: "Get Studio Registry V2 (plugin pages for Module Federation)" }
   }, async (_request, reply) => {
@@ -4268,1400 +4644,1078 @@ async function registerAdaptersRoutes(fastify, config) {
             }
           });
         }
-        platform.logger.error("Failed to fetch VectorStore usage stats", error instanceof Error ? error : new Error(String(error)));
-        return reply.code(500).send({
-          ok: false,
-          error: {
-            code: "VECTORSTORE_USAGE_STATS_ERROR",
-            message: error instanceof Error ? error.message : "Failed to fetch vectorstore statistics"
-          }
-        });
-      }
-    });
-  }
-  const cacheDailyStatsPaths = resolvePaths(basePath, "/adapters/cache/daily-stats");
-  for (const path3 of cacheDailyStatsPaths) {
-    fastify.get(path3, async (request, reply) => {
-      const analytics = platform.analytics;
-      if (!analytics.getDailyStats) {
-        return reply.code(501).send({
-          ok: false,
-          error: {
-            code: "DAILY_STATS_NOT_IMPLEMENTED",
-            message: "Analytics adapter does not support daily statistics"
-          }
-        });
-      }
-      try {
-        const dateRange = extractDateRange(request.query);
-        const statsOptions = extractStatsOptions(request.query);
-        const dailyStats = await analytics.getDailyStats({
-          type: ["cache.get.hit", "cache.get.miss", "cache.set.completed"],
-          from: dateRange.from,
-          to: dateRange.to,
-          limit: 5e4,
-          ...statsOptions
-        });
-        return reply.send({ ok: true, data: dailyStats });
-      } catch (error) {
-        if (error instanceof Error && error.message.includes("Invalid")) {
-          return reply.code(400).send({
-            ok: false,
-            error: { code: "INVALID_DATE_RANGE", message: error.message }
-          });
-        }
-        return reply.code(500).send({
-          ok: false,
-          error: {
-            code: "DAILY_STATS_ERROR",
-            message: error instanceof Error ? error.message : "Failed to fetch daily statistics"
-          }
-        });
-      }
-    });
-  }
-  const cacheUsagePaths = resolvePaths(basePath, "/adapters/cache/usage");
-  for (const path3 of cacheUsagePaths) {
-    fastify.get(path3, async (request, reply) => {
-      const analytics = platform.analytics;
-      if (!analytics.getEvents) {
-        return reply.code(501).send({
-          ok: false,
-          error: {
-            code: "ANALYTICS_NOT_IMPLEMENTED",
-            message: "Analytics adapter does not support reading events"
-          }
-        });
-      }
-      try {
-        const dateRange = extractDateRange(request.query);
-        const hitEvents = await fetchAllEventsBatched(
-          analytics,
-          {
-            type: "cache.get.hit",
-            from: dateRange.from,
-            to: dateRange.to
-          },
-          fastify
-        );
-        const missEvents = await fetchAllEventsBatched(
-          analytics,
-          {
-            type: "cache.get.miss",
-            from: dateRange.from,
-            to: dateRange.to
-          },
-          fastify
-        );
-        const setEvents = await fetchAllEventsBatched(
-          analytics,
-          {
-            type: "cache.set.completed",
-            from: dateRange.from,
-            to: dateRange.to
-          },
-          fastify
-        );
-        const totalGets = hitEvents.length + missEvents.length;
-        const hitRate = totalGets > 0 ? hitEvents.length / totalGets * 100 : 0;
-        const stats = {
-          totalGets,
-          hits: hitEvents.length,
-          misses: missEvents.length,
-          hitRate,
-          sets: setEvents.length,
-          avgGetDuration: 0,
-          avgSetDuration: 0
-        };
-        let totalGetDuration = 0;
-        for (const event of [...hitEvents, ...missEvents]) {
-          const props = getEventData(event);
-          totalGetDuration += Number(props.durationMs || 0);
-        }
-        stats.avgGetDuration = totalGets > 0 ? totalGetDuration / totalGets : 0;
-        let totalSetDuration = 0;
-        for (const event of setEvents) {
-          const props = getEventData(event);
-          totalSetDuration += Number(props.durationMs || 0);
-        }
-        stats.avgSetDuration = stats.sets > 0 ? totalSetDuration / stats.sets : 0;
-        return { ok: true, data: stats, meta: { source: "analytics-adapter" } };
-      } catch (error) {
-        if (error instanceof Error && error.message.includes("Invalid")) {
-          return reply.code(400).send({
-            ok: false,
-            error: {
-              code: "INVALID_DATE_RANGE",
-              message: error.message
-            }
-          });
-        }
-        platform.logger.error("Failed to fetch Cache usage stats", error instanceof Error ? error : new Error(String(error)));
-        return reply.code(500).send({
-          ok: false,
-          error: {
-            code: "CACHE_USAGE_STATS_ERROR",
-            message: error instanceof Error ? error.message : "Failed to fetch cache statistics"
-          }
-        });
-      }
-    });
-  }
-  const storageDailyStatsPaths = resolvePaths(basePath, "/adapters/storage/daily-stats");
-  for (const path3 of storageDailyStatsPaths) {
-    fastify.get(path3, async (request, reply) => {
-      const analytics = platform.analytics;
-      if (!analytics.getDailyStats) {
-        return reply.code(501).send({
-          ok: false,
-          error: {
-            code: "DAILY_STATS_NOT_IMPLEMENTED",
-            message: "Analytics adapter does not support daily statistics"
-          }
-        });
-      }
-      try {
-        const dateRange = extractDateRange(request.query);
-        const statsOptions = extractStatsOptions(request.query);
-        const dailyStats = await analytics.getDailyStats({
-          type: ["storage.read.completed", "storage.write.completed", "storage.delete.completed"],
-          from: dateRange.from,
-          to: dateRange.to,
-          limit: 5e4,
-          ...statsOptions
-        });
-        return reply.send({ ok: true, data: dailyStats });
-      } catch (error) {
-        if (error instanceof Error && error.message.includes("Invalid")) {
-          return reply.code(400).send({
-            ok: false,
-            error: { code: "INVALID_DATE_RANGE", message: error.message }
-          });
-        }
-        return reply.code(500).send({
-          ok: false,
-          error: {
-            code: "DAILY_STATS_ERROR",
-            message: error instanceof Error ? error.message : "Failed to fetch daily statistics"
-          }
-        });
-      }
-    });
-  }
-  const storageUsagePaths = resolvePaths(basePath, "/adapters/storage/usage");
-  for (const path3 of storageUsagePaths) {
-    fastify.get(path3, async (request, reply) => {
-      const analytics = platform.analytics;
-      if (!analytics.getEvents) {
-        return reply.code(501).send({
-          ok: false,
-          error: {
-            code: "ANALYTICS_NOT_IMPLEMENTED",
-            message: "Analytics adapter does not support reading events"
-          }
-        });
-      }
-      try {
-        const dateRange = extractDateRange(request.query);
-        const readEvents = await fetchAllEventsBatched(
-          analytics,
-          {
-            type: "storage.read.completed",
-            from: dateRange.from,
-            to: dateRange.to
-          },
-          fastify
-        );
-        const writeEvents = await fetchAllEventsBatched(
-          analytics,
-          {
-            type: "storage.write.completed",
-            from: dateRange.from,
-            to: dateRange.to
-          },
-          fastify
-        );
-        const deleteEvents = await fetchAllEventsBatched(
-          analytics,
-          {
-            type: "storage.delete.completed",
-            from: dateRange.from,
-            to: dateRange.to
-          },
-          fastify
-        );
-        const stats = {
-          readOperations: readEvents.length,
-          writeOperations: writeEvents.length,
-          deleteOperations: deleteEvents.length,
-          totalBytesRead: 0,
-          totalBytesWritten: 0,
-          avgReadDuration: 0,
-          avgWriteDuration: 0
-        };
-        let totalReadDuration = 0;
-        for (const event of readEvents) {
-          const props = getEventData(event);
-          stats.totalBytesRead += Number(props.bytesRead || 0);
-          totalReadDuration += Number(props.durationMs || 0);
-        }
-        stats.avgReadDuration = stats.readOperations > 0 ? totalReadDuration / stats.readOperations : 0;
-        let totalWriteDuration = 0;
-        for (const event of writeEvents) {
-          const props = getEventData(event);
-          stats.totalBytesWritten += Number(props.bytesWritten || 0);
-          totalWriteDuration += Number(props.durationMs || 0);
-        }
-        stats.avgWriteDuration = stats.writeOperations > 0 ? totalWriteDuration / stats.writeOperations : 0;
-        return { ok: true, data: stats, meta: { source: "analytics-adapter" } };
-      } catch (error) {
-        if (error instanceof Error && error.message.includes("Invalid")) {
-          return reply.code(400).send({
-            ok: false,
-            error: {
-              code: "INVALID_DATE_RANGE",
-              message: error.message
-            }
-          });
-        }
-        platform.logger.error("Failed to fetch Storage usage stats", error instanceof Error ? error : new Error(String(error)));
+        platform.logger.error("Failed to fetch VectorStore usage stats", error instanceof Error ? error : new Error(String(error)));
         return reply.code(500).send({
           ok: false,
           error: {
-            code: "STORAGE_USAGE_STATS_ERROR",
-            message: error instanceof Error ? error.message : "Failed to fetch storage statistics"
+            code: "VECTORSTORE_USAGE_STATS_ERROR",
+            message: error instanceof Error ? error.message : "Failed to fetch vectorstore statistics"
           }
         });
       }
     });
   }
-  fastify.log.info("Platform adapter routes registered");
-}
-function mapPinoLevelToString(level) {
-  if (typeof level === "string") {
-    return level;
-  }
-  if (level <= 10) {
-    return "trace";
-  }
-  if (level <= 20) {
-    return "debug";
-  }
-  if (level <= 30) {
-    return "info";
-  }
-  if (level <= 40) {
-    return "warn";
-  }
-  if (level <= 50) {
-    return "error";
-  }
-  return "fatal";
-}
-function toFrontendLogRecord(record) {
-  const pinoLevel = record.fields.level;
-  const levelStr = typeof pinoLevel === "number" ? mapPinoLevelToString(pinoLevel) : record.level;
-  const messageStr = typeof record.message === "string" ? record.message : JSON.stringify(record.message);
-  const { level: _level, time: _time, ...restFields } = record.fields;
-  return {
-    id: record.id,
-    // Include ID for navigation to detail page
-    time: new Date(record.timestamp).toISOString(),
-    level: levelStr,
-    msg: messageStr,
-    plugin: record.source,
-    ...restFields
-  };
-}
-function buildLogSummaryPrompt(question, logs, stats, includeContext) {
-  let prompt = `You are analyzing application logs. User question: "${question}"
-
-`;
-  prompt += `Statistics:
-`;
-  prompt += `Total logs: ${stats.total}
-`;
-  prompt += `Errors: ${stats.byLevel.error || 0}
-`;
-  prompt += `Warnings: ${stats.byLevel.warn || 0}
-`;
-  prompt += `Info: ${stats.byLevel.info || 0}
-`;
-  if (stats.timeRange.from && stats.timeRange.to) {
-    prompt += `Time range: ${stats.timeRange.from} to ${stats.timeRange.to}
-`;
-  }
-  if (stats.topErrors.length > 0) {
-    prompt += `
-Top Errors:
-`;
-    stats.topErrors.slice(0, 5).forEach((err, idx) => {
-      prompt += `${idx + 1}. "${err.message}" (${err.count} occurrences)
-`;
-    });
-  }
-  const relevantLogs = logs.filter((log) => {
-    if (!includeContext.errors && log.level === "error") {
-      return false;
-    }
-    if (!includeContext.warnings && log.level === "warn") {
-      return false;
-    }
-    if (!includeContext.info && log.level === "info") {
-      return false;
-    }
-    return true;
-  });
-  prompt += `
-Log Entries (${Math.min(relevantLogs.length, 100)} most recent):
-`;
-  relevantLogs.slice(-100).forEach((log) => {
-    prompt += `[${log.time}] ${log.level.toUpperCase()}`;
-    if (includeContext.metadata && log.plugin) {
-      prompt += ` [${log.plugin}]`;
-    }
-    prompt += `: ${log.msg || "(no message)"}
-`;
-    if (includeContext.metadata && (log.traceId || log.executionId)) {
-      if (log.traceId) {
-        prompt += `  traceId: ${log.traceId}
-`;
-      }
-      if (log.executionId) {
-        prompt += `  executionId: ${log.executionId}
-`;
-      }
-    }
-    const logErr = log.err;
-    if (includeContext.stackTraces && logErr?.stack) {
-      prompt += `  stack: ${logErr.stack.split("\n").slice(0, 5).join("\n  ")}
-`;
-    }
-  });
-  prompt += `
-Instructions:
-`;
-  prompt += `Provide a clear, concise summary answering the user's question as plain text. Focus on:
-`;
-  prompt += `1. What happened (timeline of events)
-`;
-  prompt += `2. Root causes if errors are present
-`;
-  prompt += `3. Patterns or trends you notice
-`;
-  prompt += `4. Actionable recommendations if applicable
-`;
-  prompt += `
-Keep the summary under 300 words. Use simple paragraphs separated by double newlines. Do not use markdown formatting (no **, ##, -, or other markdown syntax). Write in clear, professional language.
-`;
-  return prompt;
-}
-function extractCorrelationKeys(log) {
-  return {
-    requestId: log.fields.requestId ?? log.fields.reqId,
-    traceId: log.fields.traceId,
-    executionId: log.fields.executionId,
-    sessionId: log.fields.sessionId
-  };
-}
-async function findRelatedLogs(targetLog) {
-  const correlationKeys = extractCorrelationKeys(targetLog);
-  const timeWindow = 6e4;
-  if (correlationKeys.requestId || correlationKeys.traceId || correlationKeys.executionId) {
-    const relatedLogs = [];
-    const result2 = await platform.logs.query({
-      from: targetLog.timestamp - timeWindow,
-      to: targetLog.timestamp + timeWindow
-    }, {
-      limit: 1e3
-    });
-    for (const log of result2.logs) {
-      if (log.id === targetLog.id) {
-        continue;
-      }
-      const logKeys = extractCorrelationKeys(log);
-      if (correlationKeys.requestId && logKeys.requestId === correlationKeys.requestId || correlationKeys.traceId && logKeys.traceId === correlationKeys.traceId || correlationKeys.executionId && logKeys.executionId === correlationKeys.executionId || correlationKeys.sessionId && logKeys.sessionId === correlationKeys.sessionId) {
-        relatedLogs.push(log);
+  const cacheDailyStatsPaths = resolvePaths(basePath, "/adapters/cache/daily-stats");
+  for (const path3 of cacheDailyStatsPaths) {
+    fastify.get(path3, async (request, reply) => {
+      const analytics = platform.analytics;
+      if (!analytics.getDailyStats) {
+        return reply.code(501).send({
+          ok: false,
+          error: {
+            code: "DAILY_STATS_NOT_IMPLEMENTED",
+            message: "Analytics adapter does not support daily statistics"
+          }
+        });
       }
-    }
-    if (relatedLogs.length > 0) {
-      return relatedLogs.sort((a, b) => a.timestamp - b.timestamp).map(toFrontendLogRecord);
-    }
-  }
-  const result = await platform.logs.query({
-    source: targetLog.source,
-    from: targetLog.timestamp - timeWindow,
-    to: targetLog.timestamp + timeWindow
-  }, {
-    limit: 50
-  });
-  return result.logs.filter((log) => log.id !== targetLog.id).sort((a, b) => a.timestamp - b.timestamp).map(toFrontendLogRecord);
-}
-function generateFallbackSummary(stats, logs) {
-  let summary = `Log Summary
-
-`;
-  summary += `Total Logs: ${stats.total}
-
-`;
-  summary += `By Level:
-`;
-  Object.entries(stats.byLevel).forEach(([level, count]) => {
-    summary += `${level}: ${count}
-`;
-  });
-  summary += `
-`;
-  if (Object.keys(stats.byPlugin).length > 0) {
-    summary += `By Plugin:
-`;
-    Object.entries(stats.byPlugin).sort((a, b) => b[1] - a[1]).slice(0, 5).forEach(([plugin, count]) => {
-      summary += `${plugin}: ${count}
-`;
-    });
-    summary += `
-`;
-  }
-  if (stats.topErrors.length > 0) {
-    summary += `Top Errors:
-`;
-    stats.topErrors.slice(0, 5).forEach((err, idx) => {
-      summary += `${idx + 1}. "${err.message}" (${err.count} times)
-`;
-    });
-    summary += `
-`;
-  }
-  if (stats.timeRange.from && stats.timeRange.to) {
-    summary += `Time Range: ${stats.timeRange.from} to ${stats.timeRange.to}
-
-`;
-  }
-  summary += `Note: LLM summarization is not available. This is a basic statistical summary.`;
-  return summary;
-}
-async function registerLogRoutes(server, config, eventHub) {
-  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;
-      const query = {
-        level: request.query.level,
-        source: request.query.plugin,
-        from: request.query.from ? new Date(request.query.from).getTime() : void 0,
-        to: request.query.to ? new Date(request.query.to).getTime() : void 0
-      };
-      let result;
-      if (request.query.search) {
-        result = await platform.logs.search(request.query.search, {
-          limit,
-          offset
+      try {
+        const dateRange = extractDateRange(request.query);
+        const statsOptions = extractStatsOptions(request.query);
+        const dailyStats = await analytics.getDailyStats({
+          type: ["cache.get.hit", "cache.get.miss", "cache.set.completed"],
+          from: dateRange.from,
+          to: dateRange.to,
+          limit: 5e4,
+          ...statsOptions
         });
-      } else {
-        result = await platform.logs.query(query, {
-          limit,
-          offset
+        return reply.send({ ok: true, data: dailyStats });
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("Invalid")) {
+          return reply.code(400).send({
+            ok: false,
+            error: { code: "INVALID_DATE_RANGE", message: error.message }
+          });
+        }
+        return reply.code(500).send({
+          ok: false,
+          error: {
+            code: "DAILY_STATS_ERROR",
+            message: error instanceof Error ? error.message : "Failed to fetch daily statistics"
+          }
         });
       }
-      const frontendLogs = result.logs.map(toFrontendLogRecord);
-      const stats = await platform.logs.getStats();
-      return {
-        ok: true,
-        data: {
-          logs: frontendLogs,
-          total: result.total,
-          hasMore: result.hasMore,
-          filters: request.query,
-          source: "source" in result ? result.source : void 0,
-          stats: {
-            buffer: stats.buffer ? {
-              size: stats.buffer.size,
-              maxSize: stats.buffer.maxSize,
-              oldest: stats.buffer.oldestTimestamp ? new Date(stats.buffer.oldestTimestamp).toISOString() : void 0,
-              newest: stats.buffer.newestTimestamp ? new Date(stats.buffer.newestTimestamp).toISOString() : void 0
-            } : void 0,
-            persistence: stats.persistence ? {
-              totalLogs: stats.persistence.totalLogs,
-              oldestTimestamp: stats.persistence.oldestTimestamp ? new Date(stats.persistence.oldestTimestamp).toISOString() : void 0,
-              newestTimestamp: stats.persistence.newestTimestamp ? new Date(stats.persistence.newestTimestamp).toISOString() : void 0,
-              sizeBytes: stats.persistence.sizeBytes
-            } : void 0
+    });
+  }
+  const cacheUsagePaths = resolvePaths(basePath, "/adapters/cache/usage");
+  for (const path3 of cacheUsagePaths) {
+    fastify.get(path3, async (request, reply) => {
+      const analytics = platform.analytics;
+      if (!analytics.getEvents) {
+        return reply.code(501).send({
+          ok: false,
+          error: {
+            code: "ANALYTICS_NOT_IMPLEMENTED",
+            message: "Analytics adapter does not support reading events"
           }
-        }
-      };
-    } catch (error) {
-      return reply.code(503).send({
-        ok: false,
-        error: "Log query failed",
-        message: error instanceof Error ? error.message : "Unknown error"
-      });
-    }
-  });
-  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);
-        if (!log) {
-          return reply.code(404).send({
+        const dateRange = extractDateRange(request.query);
+        const hitEvents = await fetchAllEventsBatched(
+          analytics,
+          {
+            type: "cache.get.hit",
+            from: dateRange.from,
+            to: dateRange.to
+          },
+          fastify
+        );
+        const missEvents = await fetchAllEventsBatched(
+          analytics,
+          {
+            type: "cache.get.miss",
+            from: dateRange.from,
+            to: dateRange.to
+          },
+          fastify
+        );
+        const setEvents = await fetchAllEventsBatched(
+          analytics,
+          {
+            type: "cache.set.completed",
+            from: dateRange.from,
+            to: dateRange.to
+          },
+          fastify
+        );
+        const totalGets = hitEvents.length + missEvents.length;
+        const hitRate = totalGets > 0 ? hitEvents.length / totalGets * 100 : 0;
+        const stats = {
+          totalGets,
+          hits: hitEvents.length,
+          misses: missEvents.length,
+          hitRate,
+          sets: setEvents.length,
+          avgGetDuration: 0,
+          avgSetDuration: 0
+        };
+        let totalGetDuration = 0;
+        for (const event of [...hitEvents, ...missEvents]) {
+          const props = getEventData(event);
+          totalGetDuration += Number(props.durationMs || 0);
+        }
+        stats.avgGetDuration = totalGets > 0 ? totalGetDuration / totalGets : 0;
+        let totalSetDuration = 0;
+        for (const event of setEvents) {
+          const props = getEventData(event);
+          totalSetDuration += Number(props.durationMs || 0);
+        }
+        stats.avgSetDuration = stats.sets > 0 ? totalSetDuration / stats.sets : 0;
+        return { ok: true, data: stats, meta: { source: "analytics-adapter" } };
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("Invalid")) {
+          return reply.code(400).send({
             ok: false,
-            error: "Log not found",
-            message: `Log with ID '${request.params.id}' does not exist`
+            error: {
+              code: "INVALID_DATE_RANGE",
+              message: error.message
+            }
           });
         }
-        const frontendLog = toFrontendLogRecord(log);
-        let relatedLogs = [];
-        if (request.query.includeRelated === "true") {
-          relatedLogs = await findRelatedLogs(log);
-        }
-        return {
-          ok: true,
-          data: {
-            log: frontendLog,
-            related: relatedLogs.length > 0 ? relatedLogs : void 0
+        platform.logger.error("Failed to fetch Cache usage stats", error instanceof Error ? error : new Error(String(error)));
+        return reply.code(500).send({
+          ok: false,
+          error: {
+            code: "CACHE_USAGE_STATS_ERROR",
+            message: error instanceof Error ? error.message : "Failed to fetch cache statistics"
           }
-        };
+        });
+      }
+    });
+  }
+  const storageDailyStatsPaths = resolvePaths(basePath, "/adapters/storage/daily-stats");
+  for (const path3 of storageDailyStatsPaths) {
+    fastify.get(path3, async (request, reply) => {
+      const analytics = platform.analytics;
+      if (!analytics.getDailyStats) {
+        return reply.code(501).send({
+          ok: false,
+          error: {
+            code: "DAILY_STATS_NOT_IMPLEMENTED",
+            message: "Analytics adapter does not support daily statistics"
+          }
+        });
+      }
+      try {
+        const dateRange = extractDateRange(request.query);
+        const statsOptions = extractStatsOptions(request.query);
+        const dailyStats = await analytics.getDailyStats({
+          type: ["storage.read.completed", "storage.write.completed", "storage.delete.completed"],
+          from: dateRange.from,
+          to: dateRange.to,
+          limit: 5e4,
+          ...statsOptions
+        });
+        return reply.send({ ok: true, data: dailyStats });
       } catch (error) {
+        if (error instanceof Error && error.message.includes("Invalid")) {
+          return reply.code(400).send({
+            ok: false,
+            error: { code: "INVALID_DATE_RANGE", message: error.message }
+          });
+        }
         return reply.code(500).send({
           ok: false,
-          error: "Failed to fetch log",
-          message: error instanceof Error ? error.message : "Unknown error"
+          error: {
+            code: "DAILY_STATS_ERROR",
+            message: error instanceof Error ? error.message : "Failed to fetch daily statistics"
+          }
+        });
+      }
+    });
+  }
+  const storageUsagePaths = resolvePaths(basePath, "/adapters/storage/usage");
+  for (const path3 of storageUsagePaths) {
+    fastify.get(path3, async (request, reply) => {
+      const analytics = platform.analytics;
+      if (!analytics.getEvents) {
+        return reply.code(501).send({
+          ok: false,
+          error: {
+            code: "ANALYTICS_NOT_IMPLEMENTED",
+            message: "Analytics adapter does not support reading events"
+          }
         });
       }
-    }
-  );
-  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);
-        if (!log) {
-          return reply.code(404).send({
+        const dateRange = extractDateRange(request.query);
+        const readEvents = await fetchAllEventsBatched(
+          analytics,
+          {
+            type: "storage.read.completed",
+            from: dateRange.from,
+            to: dateRange.to
+          },
+          fastify
+        );
+        const writeEvents = await fetchAllEventsBatched(
+          analytics,
+          {
+            type: "storage.write.completed",
+            from: dateRange.from,
+            to: dateRange.to
+          },
+          fastify
+        );
+        const deleteEvents = await fetchAllEventsBatched(
+          analytics,
+          {
+            type: "storage.delete.completed",
+            from: dateRange.from,
+            to: dateRange.to
+          },
+          fastify
+        );
+        const stats = {
+          readOperations: readEvents.length,
+          writeOperations: writeEvents.length,
+          deleteOperations: deleteEvents.length,
+          totalBytesRead: 0,
+          totalBytesWritten: 0,
+          avgReadDuration: 0,
+          avgWriteDuration: 0
+        };
+        let totalReadDuration = 0;
+        for (const event of readEvents) {
+          const props = getEventData(event);
+          stats.totalBytesRead += Number(props.bytesRead || 0);
+          totalReadDuration += Number(props.durationMs || 0);
+        }
+        stats.avgReadDuration = stats.readOperations > 0 ? totalReadDuration / stats.readOperations : 0;
+        let totalWriteDuration = 0;
+        for (const event of writeEvents) {
+          const props = getEventData(event);
+          stats.totalBytesWritten += Number(props.bytesWritten || 0);
+          totalWriteDuration += Number(props.durationMs || 0);
+        }
+        stats.avgWriteDuration = stats.writeOperations > 0 ? totalWriteDuration / stats.writeOperations : 0;
+        return { ok: true, data: stats, meta: { source: "analytics-adapter" } };
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("Invalid")) {
+          return reply.code(400).send({
             ok: false,
-            error: "Log not found",
-            message: `Log with ID '${request.params.id}' does not exist`
+            error: {
+              code: "INVALID_DATE_RANGE",
+              message: error.message
+            }
           });
         }
-        const relatedLogs = await findRelatedLogs(log);
-        return {
-          ok: true,
-          data: {
-            total: relatedLogs.length,
-            logs: relatedLogs,
-            correlationKeys: extractCorrelationKeys(log)
-          }
-        };
-      } catch (error) {
+        platform.logger.error("Failed to fetch Storage usage stats", error instanceof Error ? error : new Error(String(error)));
         return reply.code(500).send({
           ok: false,
-          error: "Failed to fetch related logs",
-          message: error instanceof Error ? error.message : "Unknown error"
+          error: {
+            code: "STORAGE_USAGE_STATS_ERROR",
+            message: error instanceof Error ? error.message : "Failed to fetch storage statistics"
+          }
         });
       }
+    });
+  }
+  fastify.log.info("Platform adapter routes registered");
+}
+function mapPinoLevelToString(level) {
+  if (typeof level === "string") {
+    return level;
+  }
+  if (level <= 10) {
+    return "trace";
+  }
+  if (level <= 20) {
+    return "debug";
+  }
+  if (level <= 30) {
+    return "info";
+  }
+  if (level <= 40) {
+    return "warn";
+  }
+  if (level <= 50) {
+    return "error";
+  }
+  return "fatal";
+}
+function toFrontendLogRecord(record) {
+  const pinoLevel = record.fields.level;
+  const levelStr = typeof pinoLevel === "number" ? mapPinoLevelToString(pinoLevel) : record.level;
+  const messageStr = typeof record.message === "string" ? record.message : JSON.stringify(record.message);
+  const { level: _level, time: _time, ...restFields } = record.fields;
+  return {
+    id: record.id,
+    // Include ID for navigation to detail page
+    time: new Date(record.timestamp).toISOString(),
+    level: levelStr,
+    msg: messageStr,
+    ...restFields
+  };
+}
+function buildLogSummaryPrompt(question, logs, stats, includeContext) {
+  let prompt = `You are analyzing application logs. User question: "${question}"
+
+`;
+  prompt += `Statistics:
+`;
+  prompt += `Total logs: ${stats.total}
+`;
+  prompt += `Errors: ${stats.byLevel.error || 0}
+`;
+  prompt += `Warnings: ${stats.byLevel.warn || 0}
+`;
+  prompt += `Info: ${stats.byLevel.info || 0}
+`;
+  if (stats.timeRange.from && stats.timeRange.to) {
+    prompt += `Time range: ${stats.timeRange.from} to ${stats.timeRange.to}
+`;
+  }
+  if (stats.topErrors.length > 0) {
+    prompt += `
+Top Errors:
+`;
+    stats.topErrors.slice(0, 5).forEach((err, idx) => {
+      prompt += `${idx + 1}. "${err.message}" (${err.count} occurrences)
+`;
+    });
+  }
+  const relevantLogs = logs.filter((log) => {
+    if (!includeContext.errors && log.level === "error") {
+      return false;
     }
-  );
-  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({
-        error: "Log streaming not enabled",
-        message: "Logger adapter does not support streaming. Enable logRingBuffer in kb.config.json"
-      });
+    if (!includeContext.warnings && log.level === "warn") {
+      return false;
     }
-    reply.hijack();
-    let streamClosed = false;
-    const origin = request.headers.origin;
-    if (origin === "http://localhost:3000" || origin === "http://localhost:5173") {
-      reply.raw.setHeader("Access-Control-Allow-Origin", origin);
-      reply.raw.setHeader("Access-Control-Allow-Credentials", "true");
-    } else {
-      reply.raw.setHeader("Access-Control-Allow-Origin", "*");
+    if (!includeContext.info && log.level === "info") {
+      return false;
     }
-    reply.raw.setHeader("Content-Type", "text/event-stream");
-    reply.raw.setHeader("Cache-Control", "no-cache, no-transform");
-    reply.raw.setHeader("Connection", "keep-alive");
-    try {
-      reply.raw.flushHeaders?.();
-      reply.raw.write(": connected\n\n");
-    } catch (err) {
-      streamClosed = true;
-      return;
+    return true;
+  });
+  prompt += `
+Log Entries (${Math.min(relevantLogs.length, 100)} most recent):
+`;
+  relevantLogs.slice(-100).forEach((log) => {
+    prompt += `[${log.time}] ${log.level.toUpperCase()}`;
+    if (includeContext.metadata && log.plugin) {
+      prompt += ` [${log.plugin}]`;
     }
-    const unsubscribe = platform.logs.subscribe((log) => {
-      if (!streamClosed && !reply.raw.writableEnded && !reply.raw.destroyed) {
-        try {
-          const frontendLog = toFrontendLogRecord(log);
-          reply.raw.write(`event: log
-`);
-          reply.raw.write(`data: ${JSON.stringify(frontendLog)}
-
-`);
-        } catch (err) {
-          streamClosed = true;
-        }
+    prompt += `: ${log.msg || "(no message)"}
+`;
+    if (includeContext.metadata && (log.traceId || log.executionId)) {
+      if (log.traceId) {
+        prompt += `  traceId: ${log.traceId}
+`;
       }
-    });
-    const cleanup = () => {
-      if (!streamClosed) {
-        streamClosed = true;
-        unsubscribe();
-        try {
-          if (!reply.raw.writableEnded && !reply.raw.destroyed) {
-            reply.raw.end();
-          }
-        } catch (err) {
-        }
+      if (log.executionId) {
+        prompt += `  executionId: ${log.executionId}
+`;
       }
-    };
-    request.raw.on("close", cleanup);
-    request.raw.on("error", cleanup);
-    await new Promise(() => {
-    });
+    }
+    const logErr = log.err;
+    if (includeContext.stackTraces && logErr?.stack) {
+      prompt += `  stack: ${logErr.stack.split("\n").slice(0, 5).join("\n  ")}
+`;
+    }
   });
-  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();
-      return {
-        ok: true,
-        data: {
-          capabilities: caps,
-          buffer: stats.buffer ? {
-            size: stats.buffer.size,
-            maxSize: stats.buffer.maxSize,
-            oldest: stats.buffer.oldestTimestamp ? new Date(stats.buffer.oldestTimestamp).toISOString() : void 0,
-            newest: stats.buffer.newestTimestamp ? new Date(stats.buffer.newestTimestamp).toISOString() : void 0
-          } : void 0,
-          persistence: stats.persistence ? {
-            totalLogs: stats.persistence.totalLogs,
-            oldest: stats.persistence.oldestTimestamp ? new Date(stats.persistence.oldestTimestamp).toISOString() : void 0,
-            newest: stats.persistence.newestTimestamp ? new Date(stats.persistence.newestTimestamp).toISOString() : void 0,
-            sizeBytes: stats.persistence.sizeBytes
-          } : void 0
-        }
-      };
-    } catch (error) {
-      return reply.code(500).send({
-        ok: false,
-        error: "Failed to fetch stats",
-        message: error instanceof Error ? error.message : "Unknown error"
-      });
+  prompt += `
+Instructions:
+`;
+  prompt += `Provide a clear, concise summary answering the user's question as plain text. Focus on:
+`;
+  prompt += `1. What happened (timeline of events)
+`;
+  prompt += `2. Root causes if errors are present
+`;
+  prompt += `3. Patterns or trends you notice
+`;
+  prompt += `4. Actionable recommendations if applicable
+`;
+  prompt += `
+Keep the summary under 300 words. Use simple paragraphs separated by double newlines. Do not use markdown formatting (no **, ##, -, or other markdown syntax). Write in clear, professional language.
+`;
+  return prompt;
+}
+function extractCorrelationKeys(log) {
+  return {
+    requestId: log.fields.requestId ?? log.fields.reqId,
+    traceId: log.fields.traceId,
+    executionId: log.fields.executionId,
+    sessionId: log.fields.sessionId
+  };
+}
+async function findRelatedLogs(targetLog) {
+  const correlationKeys = extractCorrelationKeys(targetLog);
+  const timeWindow = 6e4;
+  if (correlationKeys.requestId || correlationKeys.traceId || correlationKeys.executionId) {
+    const relatedLogs = [];
+    const result2 = await platform.logs.query({
+      from: targetLog.timestamp - timeWindow,
+      to: targetLog.timestamp + timeWindow
+    }, {
+      limit: 1e3
+    });
+    for (const log of result2.logs) {
+      if (log.id === targetLog.id) {
+        continue;
+      }
+      const logKeys = extractCorrelationKeys(log);
+      if (correlationKeys.requestId && logKeys.requestId === correlationKeys.requestId || correlationKeys.traceId && logKeys.traceId === correlationKeys.traceId || correlationKeys.executionId && logKeys.executionId === correlationKeys.executionId || correlationKeys.sessionId && logKeys.sessionId === correlationKeys.sessionId) {
+        relatedLogs.push(log);
+      }
+    }
+    if (relatedLogs.length > 0) {
+      return relatedLogs.sort((a, b) => a.timestamp - b.timestamp).map(toFrontendLogRecord);
     }
+  }
+  const result = await platform.logs.query({
+    source: targetLog.source,
+    from: targetLog.timestamp - timeWindow,
+    to: targetLog.timestamp + timeWindow
+  }, {
+    limit: 50
   });
-  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;
+  return result.logs.filter((log) => log.id !== targetLog.id).sort((a, b) => a.timestamp - b.timestamp).map(toFrontendLogRecord);
+}
+function generateFallbackSummary(stats, logs) {
+  let summary = `Log Summary
+
+`;
+  summary += `Total Logs: ${stats.total}
+
+`;
+  summary += `By Level:
+`;
+  Object.entries(stats.byLevel).forEach(([level, count]) => {
+    summary += `${level}: ${count}
+`;
+  });
+  summary += `
+`;
+  if (Object.keys(stats.byPlugin).length > 0) {
+    summary += `By Plugin:
+`;
+    Object.entries(stats.byPlugin).sort((a, b) => b[1] - a[1]).slice(0, 5).forEach(([plugin, count]) => {
+      summary += `${plugin}: ${count}
+`;
+    });
+    summary += `
+`;
+  }
+  if (stats.topErrors.length > 0) {
+    summary += `Top Errors:
+`;
+    stats.topErrors.slice(0, 5).forEach((err, idx) => {
+      summary += `${idx + 1}. "${err.message}" (${err.count} times)
+`;
+    });
+    summary += `
+`;
+  }
+  if (stats.timeRange.from && stats.timeRange.to) {
+    summary += `Time Range: ${stats.timeRange.from} to ${stats.timeRange.to}
+
+`;
+  }
+  summary += `Note: LLM summarization is not available. This is a basic statistical summary.`;
+  return summary;
+}
+async function registerLogRoutes(server, config, eventHub) {
+  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;
       const query = {
-        level: filters?.level,
-        source: filters?.plugin,
-        from: timeRange?.from ? new Date(timeRange.from).getTime() : void 0,
-        to: timeRange?.to ? new Date(timeRange.to).getTime() : void 0
-      };
-      const result = await platform.logs.query(query, { limit: 1e3 });
-      const frontendLogs = result.logs.map(toFrontendLogRecord);
-      let filteredLogs = frontendLogs;
-      if (filters?.traceId) {
-        filteredLogs = filteredLogs.filter((log) => log.traceId === filters.traceId);
-      }
-      if (filters?.executionId) {
-        filteredLogs = filteredLogs.filter((log) => log.executionId === filters.executionId);
-      }
-      const stats = {
-        total: filteredLogs.length,
-        byLevel: {},
-        byPlugin: {},
-        topErrors: [],
-        timeRange: {
-          from: filteredLogs.length > 0 ? filteredLogs[0].time : null,
-          to: filteredLogs.length > 0 ? filteredLogs[filteredLogs.length - 1].time : null
-        }
+        level: request.query.level,
+        source: request.query.plugin,
+        from: request.query.from ? new Date(request.query.from).getTime() : void 0,
+        to: request.query.to ? new Date(request.query.to).getTime() : void 0
       };
-      const errorMessages = /* @__PURE__ */ new Map();
-      for (const log of filteredLogs) {
-        stats.byLevel[log.level] = (stats.byLevel[log.level] || 0) + 1;
-        if (log.plugin) {
-          stats.byPlugin[log.plugin] = (stats.byPlugin[log.plugin] || 0) + 1;
-        }
-        if (log.level === "error" && log.msg) {
-          errorMessages.set(log.msg, (errorMessages.get(log.msg) || 0) + 1);
-        }
-      }
-      stats.topErrors = Array.from(errorMessages.entries()).map(([message2, count]) => ({ message: message2, count })).sort((a, b) => b.count - a.count).slice(0, 10);
-      let groups = null;
-      if (groupBy) {
-        const fieldMap = {
-          trace: "traceId",
-          execution: "executionId",
-          plugin: "plugin"
-        };
-        const groupMap = /* @__PURE__ */ new Map();
-        for (const log of filteredLogs) {
-          const fieldName = fieldMap[groupBy] || groupBy;
-          const key = String(log[fieldName] || "unknown");
-          if (!groupMap.has(key)) {
-            groupMap.set(key, []);
-          }
-          groupMap.get(key).push(log);
-        }
-        groups = Object.fromEntries(groupMap.entries());
-      }
-      let aiSummary = null;
-      let message = null;
-      if (platform.llm && question) {
-        try {
-          const context = includeContext || {
-            errors: true,
-            warnings: true,
-            info: false,
-            metadata: true,
-            stackTraces: true
-          };
-          const prompt = buildLogSummaryPrompt(question, filteredLogs, stats, context);
-          const response = await platform.llm.complete(prompt, {
-            temperature: 0.7,
-            maxTokens: 1e3,
-            systemPrompt: "You are a technical log analysis assistant. Provide clear, actionable insights based on application logs."
-          });
-          aiSummary = response.content.trim();
-        } catch (error) {
-          platform.logger.warn("LLM summarization failed, using fallback", {
-            error: error instanceof Error ? error.message : String(error)
-          });
-          aiSummary = generateFallbackSummary(stats, filteredLogs);
-          message = "AI summarization unavailable, showing statistical summary";
-        }
+      let result;
+      if (request.query.search) {
+        result = await platform.logs.search(request.query.search, {
+          limit,
+          offset
+        });
       } else {
-        aiSummary = generateFallbackSummary(stats, filteredLogs);
-        message = platform.llm ? "No question provided" : "LLM not configured";
+        result = await platform.logs.query(query, {
+          limit,
+          offset
+        });
       }
+      const frontendLogs = result.logs.map(toFrontendLogRecord);
+      const stats = await platform.logs.getStats();
       return {
         ok: true,
         data: {
-          summary: {
-            question: question || "General log summary",
-            timeRange: stats.timeRange,
-            total: stats.total,
-            stats,
-            groups
-          },
-          aiSummary,
-          message
+          logs: frontendLogs,
+          total: result.total,
+          hasMore: result.hasMore,
+          filters: request.query,
+          source: "source" in result ? result.source : void 0,
+          stats: {
+            buffer: stats.buffer ? {
+              size: stats.buffer.size,
+              maxSize: stats.buffer.maxSize,
+              oldest: stats.buffer.oldestTimestamp ? new Date(stats.buffer.oldestTimestamp).toISOString() : void 0,
+              newest: stats.buffer.newestTimestamp ? new Date(stats.buffer.newestTimestamp).toISOString() : void 0
+            } : void 0,
+            persistence: stats.persistence ? {
+              totalLogs: stats.persistence.totalLogs,
+              oldestTimestamp: stats.persistence.oldestTimestamp ? new Date(stats.persistence.oldestTimestamp).toISOString() : void 0,
+              newestTimestamp: stats.persistence.newestTimestamp ? new Date(stats.persistence.newestTimestamp).toISOString() : void 0,
+              sizeBytes: stats.persistence.sizeBytes
+            } : void 0
+          }
         }
       };
     } catch (error) {
-      return reply.code(500).send({
+      return reply.code(503).send({
         ok: false,
-        error: "Log summarization failed",
+        error: "Log query failed",
         message: error instanceof Error ? error.message : "Unknown error"
       });
     }
   });
-}
-var SENSITIVE_KEYS = [
-  "apiKey",
-  "secret",
-  "password",
-  "token",
-  "key",
-  "credentials",
-  "auth"
-];
-function redactSensitiveData(obj, redacted = [], path3 = "") {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    const currentPath = path3 ? `${path3}.${key}` : key;
-    const lowerKey = key.toLowerCase();
-    const isSensitive = SENSITIVE_KEYS.some((pattern) => lowerKey.includes(pattern.toLowerCase()));
-    if (isSensitive && typeof value === "string") {
-      result[key] = "***REDACTED***";
-      redacted.push(currentPath);
-    } else if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-      result[key] = redactSensitiveData(value, redacted, currentPath);
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-async function loadPlatformConfig(repoRoot) {
-  try {
-    const configResult = await readKbConfig(repoRoot);
-    if (!configResult || !configResult.data) {
-      return {
-        adapters: {},
-        adapterOptions: {},
-        execution: { mode: "in-process" }
-      };
-    }
-    const config = configResult.data;
-    const configPlatform = typeof config.platform === "object" && config.platform !== null ? config.platform : {};
-    return {
-      adapters: configPlatform.adapters ?? {},
-      adapterOptions: configPlatform.adapterOptions ?? {},
-      execution: configPlatform.execution ?? { mode: "in-process" }
-    };
-  } catch (error) {
-    return {
-      adapters: {},
-      adapterOptions: {},
-      execution: { mode: "in-process" }
-    };
-  }
-}
-async function registerPlatformRoutes(fastify, config, repoRoot) {
-  const basePath = normalizeBasePath(config.basePath);
-  const configPaths = resolvePaths(basePath, "/platform/config");
-  for (const path3 of configPaths) {
-    fastify.get(path3, async (_request, reply) => {
-      try {
-        const { adapters, adapterOptions, execution } = await restDomainOperationMetrics.observeOperation(
-          "platform.config.get",
-          () => loadPlatformConfig(repoRoot)
-        );
-        const redacted = [];
-        const sanitizedOptions = redactSensitiveData(adapterOptions, redacted);
-        const payload = {
-          schema: "kb.platform.config/1",
-          ts: (/* @__PURE__ */ new Date()).toISOString(),
-          adapters,
-          adapterOptions: sanitizedOptions,
-          execution,
-          redacted
-        };
-        const response = {
+  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);
+        if (!log) {
+          return reply.code(404).send({
+            ok: false,
+            error: "Log not found",
+            message: `Log with ID '${request.params.id}' does not exist`
+          });
+        }
+        const frontendLog = toFrontendLogRecord(log);
+        let relatedLogs = [];
+        if (request.query.includeRelated === "true") {
+          relatedLogs = await findRelatedLogs(log);
+        }
+        return {
           ok: true,
-          data: payload
+          data: {
+            log: frontendLog,
+            related: relatedLogs.length > 0 ? relatedLogs : void 0
+          }
         };
-        return reply.send(response);
       } catch (error) {
-        platform.logger.error("Failed to load platform config", error instanceof Error ? error : new Error(String(error)));
         return reply.code(500).send({
           ok: false,
-          error: {
-            code: "INTERNAL_SERVER_ERROR",
-            message: "Failed to load platform configuration"
-          }
+          error: "Failed to fetch log",
+          message: error instanceof Error ? error.message : "Unknown error"
         });
       }
-    });
-  }
-}
-var AdapterRegistry = class {
-  methods = /* @__PURE__ */ new Map();
-  register(adapter, method, entry) {
-    this.methods.set(`${adapter}.${method}`, entry);
-  }
-  get(adapter, method) {
-    return this.methods.get(`${adapter}.${method}`);
-  }
-  has(adapter, method) {
-    return this.methods.has(`${adapter}.${method}`);
-  }
-};
-var AdapterCallRequestSchema = z.object({
-  requestId: z.string(),
-  adapter: AdapterNameSchema,
-  method: z.string(),
-  args: z.array(z.unknown()),
-  context: z.object({
-    namespaceId: z.string(),
-    hostId: z.string(),
-    workspaceId: z.string().optional(),
-    environmentId: z.string().optional(),
-    executionRequestId: z.string().optional(),
-    userId: z.string().optional(),
-    sessionId: z.string().optional()
-  })
-});
-function createAdapterRegistry() {
-  const registry = new AdapterRegistry();
-  registry.register("llm", "complete", {
-    inputSchema: z.array(z.unknown()),
-    outputSchema: z.unknown(),
-    execute: async (args) => {
-      const llm = platform.getAdapter("llm");
-      if (!llm) {
-        throw new Error("LLM adapter not available");
-      }
-      return llm.complete(...args);
     }
-  });
-  registry.register("cache", "get", {
-    inputSchema: z.array(z.unknown()),
-    outputSchema: z.unknown().nullable(),
-    execute: async (args) => platform.cache.get(args[0])
-  });
-  registry.register("cache", "set", {
-    inputSchema: z.array(z.unknown()),
-    outputSchema: z.void(),
-    execute: async (args) => platform.cache.set(args[0], args[1], args[2])
-  });
-  registry.register("cache", "delete", {
-    inputSchema: z.array(z.unknown()),
-    outputSchema: z.void(),
-    execute: async (args) => platform.cache.delete(args[0])
-  });
-  registry.register("vectorStore", "search", {
-    inputSchema: z.array(z.unknown()),
-    outputSchema: z.unknown(),
-    execute: async (args) => {
-      const vs = platform.getAdapter("vectorStore");
-      if (!vs) {
-        throw new Error("VectorStore adapter not available");
+  );
+  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);
+        if (!log) {
+          return reply.code(404).send({
+            ok: false,
+            error: "Log not found",
+            message: `Log with ID '${request.params.id}' does not exist`
+          });
+        }
+        const relatedLogs = await findRelatedLogs(log);
+        return {
+          ok: true,
+          data: {
+            total: relatedLogs.length,
+            logs: relatedLogs,
+            correlationKeys: extractCorrelationKeys(log)
+          }
+        };
+      } catch (error) {
+        return reply.code(500).send({
+          ok: false,
+          error: "Failed to fetch related logs",
+          message: error instanceof Error ? error.message : "Unknown error"
+        });
       }
-      return vs.search(...args);
     }
-  });
-  registry.register("embeddings", "embed", {
-    inputSchema: z.array(z.unknown()),
-    outputSchema: z.unknown(),
-    execute: async (args) => {
-      const emb = platform.getAdapter("embeddings");
-      if (!emb) {
-        throw new Error("Embeddings adapter not available");
-      }
-      return emb.embed(...args);
+  );
+  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({
+        error: "Log streaming not enabled",
+        message: "Logger adapter does not support streaming. Enable logRingBuffer in kb.config.json"
+      });
     }
-  });
-  registry.register("storage", "read", {
-    inputSchema: z.array(z.unknown()),
-    outputSchema: z.unknown(),
-    execute: async (args) => {
-      const storage = platform.getAdapter("storage");
-      if (!storage) {
-        throw new Error("Storage adapter not available");
-      }
-      return storage.read(...args);
+    reply.hijack();
+    let streamClosed = false;
+    const origin = request.headers.origin;
+    if (origin === "http://localhost:3000" || origin === "http://localhost:5173") {
+      reply.raw.setHeader("Access-Control-Allow-Origin", origin);
+      reply.raw.setHeader("Access-Control-Allow-Credentials", "true");
+    } else {
+      reply.raw.setHeader("Access-Control-Allow-Origin", "*");
     }
-  });
-  registry.register("storage", "write", {
-    inputSchema: z.array(z.unknown()),
-    outputSchema: z.void(),
-    execute: async (args) => {
-      const storage = platform.getAdapter("storage");
-      if (!storage) {
-        throw new Error("Storage adapter not available");
-      }
-      return storage.write(...args);
+    reply.raw.setHeader("Content-Type", "text/event-stream");
+    reply.raw.setHeader("Cache-Control", "no-cache, no-transform");
+    reply.raw.setHeader("Connection", "keep-alive");
+    try {
+      reply.raw.flushHeaders?.();
+      reply.raw.write(": connected\n\n");
+    } catch (err) {
+      streamClosed = true;
+      return;
     }
+    const unsubscribe = platform.logs.subscribe((log) => {
+      if (!streamClosed && !reply.raw.writableEnded && !reply.raw.destroyed) {
+        try {
+          const frontendLog = toFrontendLogRecord(log);
+          reply.raw.write(`event: log
+`);
+          reply.raw.write(`data: ${JSON.stringify(frontendLog)}
+
+`);
+        } catch (err) {
+          streamClosed = true;
+        }
+      }
+    });
+    const cleanup = () => {
+      if (!streamClosed) {
+        streamClosed = true;
+        unsubscribe();
+        try {
+          if (!reply.raw.writableEnded && !reply.raw.destroyed) {
+            reply.raw.end();
+          }
+        } catch (err) {
+        }
+      }
+    };
+    request.raw.on("close", cleanup);
+    request.raw.on("error", cleanup);
+    await new Promise(() => {
+    });
   });
-  return registry;
-}
-async function registerAdapterCallRoutes(server) {
-  const registry = createAdapterRegistry();
-  const internalSecret = process.env.GATEWAY_INTERNAL_SECRET;
-  const logger = platform.logger.child({ layer: "rest", route: "adapter-call" });
-  server.post("/api/v1/internal/adapter-call", async (request, reply) => {
-    const provided = request.headers["x-internal-secret"];
-    if (!internalSecret || provided !== internalSecret) {
-      return reply.code(403).send({ ok: false, error: { code: "FORBIDDEN", message: "Invalid internal secret", retryable: false } });
-    }
-    const parsed = AdapterCallRequestSchema.safeParse(request.body);
-    if (!parsed.success) {
-      return reply.code(400).send({ ok: false, error: { code: "VALIDATION_ERROR", message: parsed.error.message, retryable: false } });
-    }
-    const { requestId, adapter, method, args, context } = parsed.data;
-    const startMs = Date.now();
-    const entry = registry.get(adapter, method);
-    if (!entry) {
-      logger.warn("Adapter call rejected", { requestId, adapter, method, hostId: context.hostId });
-      return reply.code(403).send({ ok: false, error: { code: "ADAPTER_CALL_REJECTED", message: `Method not allowed: ${adapter}.${method}`, retryable: false } });
-    }
+  server.get("/api/v1/logs/stats", { schema: { tags: ["Logs"], summary: "Get log storage statistics" } }, async (request, reply) => {
     try {
-      const operation = `adapter.call.${adapter}.${method}`;
-      const result = await restDomainOperationMetrics.observeOperation(
-        operation,
-        async () => entry.execute(args, context)
-      );
-      const latencyMs = Date.now() - startMs;
-      logger.info("Adapter call success", { requestId, adapter, method, hostId: context.hostId, latencyMs });
-      return { ok: true, result };
-    } catch (err) {
-      const latencyMs = Date.now() - startMs;
-      const message = err instanceof Error ? err.message : String(err);
-      logger.error("Adapter call failed", err instanceof Error ? err : void 0, { requestId, adapter, method, hostId: context.hostId, latencyMs });
+      const stats = await platform.logs.getStats();
+      const caps = platform.logs.getCapabilities();
+      return {
+        ok: true,
+        data: {
+          capabilities: caps,
+          buffer: stats.buffer ? {
+            size: stats.buffer.size,
+            maxSize: stats.buffer.maxSize,
+            oldest: stats.buffer.oldestTimestamp ? new Date(stats.buffer.oldestTimestamp).toISOString() : void 0,
+            newest: stats.buffer.newestTimestamp ? new Date(stats.buffer.newestTimestamp).toISOString() : void 0
+          } : void 0,
+          persistence: stats.persistence ? {
+            totalLogs: stats.persistence.totalLogs,
+            oldest: stats.persistence.oldestTimestamp ? new Date(stats.persistence.oldestTimestamp).toISOString() : void 0,
+            newest: stats.persistence.newestTimestamp ? new Date(stats.persistence.newestTimestamp).toISOString() : void 0,
+            sizeBytes: stats.persistence.sizeBytes
+          } : void 0
+        }
+      };
+    } catch (error) {
       return reply.code(500).send({
         ok: false,
-        error: { code: "ADAPTER_ERROR", message, retryable: false }
+        error: "Failed to fetch stats",
+        message: error instanceof Error ? error.message : "Unknown error"
       });
     }
   });
-}
-
-// src/routes/debug-routes.ts
-var collectedRoutes = [];
-var seenRoutes = /* @__PURE__ */ new Set();
-function collectRoute(routeOptions) {
-  const methods = Array.isArray(routeOptions.method) ? routeOptions.method : [routeOptions.method];
-  for (const method of methods) {
-    if (method === "HEAD") {
-      continue;
-    }
-    const url = routeOptions.url;
-    const key = `${method}:${url}`;
-    if (!seenRoutes.has(key)) {
-      seenRoutes.add(key);
-      collectedRoutes.push({ method, url });
-    }
-  }
-}
-function registerRouteCollector(fastify) {
-  fastify.addHook("onRoute", collectRoute);
-}
-async function registerDebugRoutes(fastify, config) {
-  const basePath = normalizeBasePath(config.basePath);
-  const routesPaths = resolvePaths(basePath, "/routes");
-  for (const path3 of routesPaths) {
-    fastify.get(path3, async (_request, reply) => {
-      let routes = collectedRoutes.filter((r) => r.url.startsWith("/api/"));
-      if (routes.length === 0) {
-        routes = [...collectedRoutes];
+  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 = {
+        level: filters?.level,
+        source: filters?.plugin,
+        from: timeRange?.from ? new Date(timeRange.from).getTime() : void 0,
+        to: timeRange?.to ? new Date(timeRange.to).getTime() : void 0
+      };
+      const result = await platform.logs.query(query, { limit: 1e3 });
+      const frontendLogs = result.logs.map(toFrontendLogRecord);
+      let filteredLogs = frontendLogs;
+      if (filters?.traceId) {
+        filteredLogs = filteredLogs.filter((log) => log.traceId === filters.traceId);
       }
-      routes.sort((a, b) => {
-        const urlCompare = a.url.localeCompare(b.url);
-        if (urlCompare !== 0) {
-          return urlCompare;
+      if (filters?.executionId) {
+        filteredLogs = filteredLogs.filter((log) => log.executionId === filters.executionId);
+      }
+      const stats = {
+        total: filteredLogs.length,
+        byLevel: {},
+        byPlugin: {},
+        topErrors: [],
+        timeRange: {
+          from: filteredLogs.length > 0 ? filteredLogs[0].time : null,
+          to: filteredLogs.length > 0 ? filteredLogs[filteredLogs.length - 1].time : null
+        }
+      };
+      const errorMessages = /* @__PURE__ */ new Map();
+      for (const log of filteredLogs) {
+        stats.byLevel[log.level] = (stats.byLevel[log.level] || 0) + 1;
+        if (log.plugin) {
+          stats.byPlugin[log.plugin] = (stats.byPlugin[log.plugin] || 0) + 1;
+        }
+        if (log.level === "error" && log.msg) {
+          errorMessages.set(log.msg, (errorMessages.get(log.msg) || 0) + 1);
         }
-        return a.method.localeCompare(b.method);
-      });
-      let raw = null;
-      try {
-        raw = fastify.printRoutes({ commonPrefix: false });
-      } catch {
       }
-      return reply.send({
-        schema: "kb.routes/1",
-        ts: (/* @__PURE__ */ new Date()).toISOString(),
-        count: routes.length,
-        routes,
-        raw
-      });
-    });
-  }
-}
-
-// src/services/historical-metrics.ts
-var DEFAULT_CONFIG = {
-  intervalMs: 5e3,
-  maxPoints: {
-    "1m": 12,
-    "5m": 60,
-    "10m": 120,
-    "30m": 360,
-    "1h": 720
-  },
-  debug: false
-};
-var HistoricalMetricsCollector = class {
-  cache;
-  config;
-  intervalHandle = null;
-  logger;
-  startTimeMs = Date.now();
-  constructor(cache, config = {}, logger = console) {
-    this.cache = cache;
-    this.config = { ...DEFAULT_CONFIG, ...config, maxPoints: { ...DEFAULT_CONFIG.maxPoints, ...config.maxPoints } };
-    this.logger = logger;
-  }
-  /**
-   * Start background collection
-   */
-  start() {
-    if (this.intervalHandle) {
-      this.log("warn", "Historical metrics collector already started");
-      return;
-    }
-    this.log("info", "Starting historical metrics collector", {
-      intervalMs: this.config.intervalMs
-    });
-    this.collect().catch((err) => {
-      this.log("error", "Failed to collect initial metrics", { err });
-    });
-    this.intervalHandle = setInterval(() => {
-      this.collect().catch((err) => {
-        this.log("error", "Failed to collect metrics", { err });
-      });
-    }, this.config.intervalMs);
-  }
-  /**
-   * Stop background collection
-   */
-  stop() {
-    if (this.intervalHandle) {
-      clearInterval(this.intervalHandle);
-      this.intervalHandle = null;
-      this.log("info", "Historical metrics collector stopped");
-    }
-  }
-  /**
-   * Collect current metrics snapshot and store in cache
-   */
-  async collect() {
-    const now = Date.now();
-    const metrics = metricsCollector.getMetrics();
-    const snapshot = {
-      timestamp: now,
-      requests: {
-        total: metrics.requests.total,
-        success: metrics.requests.success ?? 0,
-        clientErrors: metrics.requests.clientErrors ?? 0,
-        serverErrors: metrics.requests.serverErrors ?? 0
-      },
-      latency: {
-        average: metrics.latency.average,
-        min: metrics.latency.min === Infinity ? 0 : metrics.latency.min,
-        max: metrics.latency.max
-      },
-      uptime: (now - metrics.timestamps.startTime) / 1e3,
-      perPlugin: metrics.perPlugin.map((p) => ({
-        pluginId: p.pluginId,
-        requests: p.total,
-        errors: Object.values(p.statuses).filter((_, idx) => Object.keys(p.statuses)[idx]?.startsWith("4") || Object.keys(p.statuses)[idx]?.startsWith("5")).reduce((sum, count) => sum + count, 0),
-        avgLatency: p.total > 0 ? p.totalDuration / p.total : 0
-      }))
-    };
-    await Promise.all([
-      this.appendToTimeSeries("1m", snapshot, 2 * 60 * 1e3),
-      // TTL: 2 minutes
-      this.appendToTimeSeries("5m", snapshot, 10 * 60 * 1e3),
-      // TTL: 10 minutes
-      this.appendToTimeSeries("10m", snapshot, 20 * 60 * 1e3),
-      // TTL: 20 minutes
-      this.appendToTimeSeries("30m", snapshot, 60 * 60 * 1e3),
-      // TTL: 1 hour
-      this.appendToTimeSeries("1h", snapshot, 2 * 60 * 60 * 1e3)
-      // TTL: 2 hours
-    ]);
-    if (now % 6e4 < this.config.intervalMs) {
-      await this.updateHeatmapAggregation(snapshot).catch((err) => {
-        this.log("error", "Failed to update heatmap", { err });
-      });
-    }
-    this.log("debug", "Metrics snapshot collected", {
-      timestamp: new Date(now).toISOString(),
-      requests: snapshot.requests.total,
-      latency: snapshot.latency.average.toFixed(2)
-    });
-  }
-  /**
-   * Append snapshot to time series bucket
-   */
-  async appendToTimeSeries(range, snapshot, ttlMs) {
-    const key = `metrics:history:${range}`;
-    const maxPoints = this.config.maxPoints[range] ?? 120;
-    let timeSeries = await this.cache.get(key);
-    if (!timeSeries || !Array.isArray(timeSeries)) {
-      timeSeries = [];
-    }
-    timeSeries.push(snapshot);
-    if (timeSeries.length > maxPoints) {
-      timeSeries = timeSeries.slice(timeSeries.length - maxPoints);
-    }
-    await this.cache.set(key, timeSeries, ttlMs);
-  }
-  /**
-   * Update heatmap aggregation for weekly patterns
-   */
-  async updateHeatmapAggregation(snapshot) {
-    const key = "metrics:heatmap:7d";
-    const ttlMs = 24 * 60 * 60 * 1e3;
-    let heatmapData = await this.cache.get(key);
-    if (!heatmapData || typeof heatmapData !== "object") {
-      heatmapData = { latency: [], errors: [], requests: [] };
-    }
-    const date = new Date(snapshot.timestamp);
-    const day = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"][date.getDay()];
-    const hour = date.getHours();
-    for (const metricType of ["latency", "errors", "requests"]) {
-      let cells = heatmapData[metricType] || [];
-      const cellIndex = cells.findIndex((c) => c.day === day && c.hour === hour);
-      let value = 0;
-      if (metricType === "latency") {
-        value = snapshot.latency.average;
-      } else if (metricType === "errors") {
-        value = snapshot.requests.clientErrors + snapshot.requests.serverErrors;
-      } else {
-        value = snapshot.requests.total;
+      stats.topErrors = Array.from(errorMessages.entries()).map(([message2, count]) => ({ message: message2, count })).sort((a, b) => b.count - a.count).slice(0, 10);
+      let groups = null;
+      if (groupBy) {
+        const fieldMap = {
+          trace: "traceId",
+          execution: "executionId",
+          plugin: "plugin"
+        };
+        const groupMap = /* @__PURE__ */ new Map();
+        for (const log of filteredLogs) {
+          const fieldName = fieldMap[groupBy] || groupBy;
+          const key = String(log[fieldName] || "unknown");
+          if (!groupMap.has(key)) {
+            groupMap.set(key, []);
+          }
+          groupMap.get(key).push(log);
+        }
+        groups = Object.fromEntries(groupMap.entries());
       }
-      if (cellIndex >= 0 && cells[cellIndex]) {
-        cells[cellIndex].value = cells[cellIndex].value * 0.9 + value * 0.1;
+      let aiSummary = null;
+      let message = null;
+      if (platform.llm && question) {
+        try {
+          const context = includeContext || {
+            errors: true,
+            warnings: true,
+            info: false,
+            metadata: true,
+            stackTraces: true
+          };
+          const prompt = buildLogSummaryPrompt(question, filteredLogs, stats, context);
+          const response = await platform.llm.complete(prompt, {
+            temperature: 0.7,
+            maxTokens: 1e3,
+            systemPrompt: "You are a technical log analysis assistant. Provide clear, actionable insights based on application logs."
+          });
+          aiSummary = response.content.trim();
+        } catch (error) {
+          platform.logger.warn("LLM summarization failed, using fallback", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+          aiSummary = generateFallbackSummary(stats, filteredLogs);
+          message = "AI summarization unavailable, showing statistical summary";
+        }
       } else {
-        cells.push({ day, hour, value });
-      }
-      if (cells.length > 168) {
-        cells = cells.slice(cells.length - 168);
+        aiSummary = generateFallbackSummary(stats, filteredLogs);
+        message = platform.llm ? "No question provided" : "LLM not configured";
       }
-      heatmapData[metricType] = cells;
+      return {
+        ok: true,
+        data: {
+          summary: {
+            question: question || "General log summary",
+            timeRange: stats.timeRange,
+            total: stats.total,
+            stats,
+            groups
+          },
+          aiSummary,
+          message
+        }
+      };
+    } catch (error) {
+      return reply.code(500).send({
+        ok: false,
+        error: "Log summarization failed",
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
     }
-    await this.cache.set(key, heatmapData, ttlMs);
-  }
-  /**
-   * Query historical time-series data
-   */
-  async queryHistory(params) {
-    const key = `metrics:history:${params.range}`;
-    const timeSeries = await this.cache.get(key);
-    if (!timeSeries || !Array.isArray(timeSeries)) {
-      return [];
+  });
+}
+var SENSITIVE_KEYS = [
+  "apiKey",
+  "secret",
+  "password",
+  "token",
+  "key",
+  "credentials",
+  "auth"
+];
+function redactSensitiveData(obj, redacted = [], path3 = "") {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const currentPath = path3 ? `${path3}.${key}` : key;
+    const lowerKey = key.toLowerCase();
+    const isSensitive = SENSITIVE_KEYS.some((pattern) => lowerKey.includes(pattern.toLowerCase()));
+    if (isSensitive && typeof value === "string") {
+      result[key] = "***REDACTED***";
+      redacted.push(currentPath);
+    } else if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      result[key] = redactSensitiveData(value, redacted, currentPath);
+    } else {
+      result[key] = value;
     }
-    const dataPoints = timeSeries.map((snapshot) => {
-      let value = 0;
-      switch (params.metric) {
-        case "requests":
-          value = snapshot.requests.total;
-          break;
-        case "errors":
-          value = snapshot.requests.clientErrors + snapshot.requests.serverErrors;
-          break;
-        case "latency":
-          value = snapshot.latency.average;
-          break;
-        case "uptime":
-          value = snapshot.uptime;
-          break;
-      }
+  }
+  return result;
+}
+async function loadPlatformConfig(repoRoot) {
+  try {
+    const configResult = await readKbConfig(repoRoot);
+    if (!configResult || !configResult.data) {
       return {
-        timestamp: snapshot.timestamp,
-        value
+        adapters: {},
+        adapterOptions: {},
+        execution: { mode: "in-process" }
       };
-    });
-    if (params.interval && params.interval !== "5s") {
-      return this.aggregateByInterval(dataPoints, params.interval);
     }
-    return dataPoints;
+    const config = configResult.data;
+    const configPlatform = typeof config.platform === "object" && config.platform !== null ? config.platform : {};
+    return {
+      adapters: configPlatform.adapters ?? {},
+      adapterOptions: configPlatform.adapterOptions ?? {},
+      execution: configPlatform.execution ?? { mode: "in-process" }
+    };
+  } catch (error) {
+    return {
+      adapters: {},
+      adapterOptions: {},
+      execution: { mode: "in-process" }
+    };
   }
-  /**
-   * Query heatmap data
-   */
-  async queryHeatmap(params) {
-    const key = "metrics:heatmap:7d";
-    const heatmapData = await this.cache.get(key);
-    if (!heatmapData || typeof heatmapData !== "object") {
-      return this.generateEmptyHeatmap();
-    }
-    const cells = heatmapData[params.metric] || [];
-    if (cells.length === 0) {
-      return this.generateEmptyHeatmap();
-    }
-    return this.fillHeatmapGaps(cells);
+}
+async function registerPlatformRoutes(fastify, config, repoRoot) {
+  const basePath = normalizeBasePath(config.basePath);
+  const configPaths = resolvePaths(basePath, "/platform/config");
+  for (const path3 of configPaths) {
+    fastify.get(path3, async (_request, reply) => {
+      try {
+        const { adapters, adapterOptions, execution } = await restDomainOperationMetrics.observeOperation(
+          "platform.config.get",
+          () => loadPlatformConfig(repoRoot)
+        );
+        const redacted = [];
+        const sanitizedOptions = redactSensitiveData(adapterOptions, redacted);
+        const payload = {
+          schema: "kb.platform.config/1",
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          adapters,
+          adapterOptions: sanitizedOptions,
+          execution,
+          redacted
+        };
+        const response = {
+          ok: true,
+          data: payload
+        };
+        return reply.send(response);
+      } catch (error) {
+        platform.logger.error("Failed to load platform config", error instanceof Error ? error : new Error(String(error)));
+        return reply.code(500).send({
+          ok: false,
+          error: {
+            code: "INTERNAL_SERVER_ERROR",
+            message: "Failed to load platform configuration"
+          }
+        });
+      }
+    });
   }
-  /**
-   * Generate empty heatmap structure (7 days × 24 hours)
-   */
-  generateEmptyHeatmap() {
-    const days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
-    const cells = [];
-    for (const day of days) {
-      for (let hour = 0; hour < 24; hour++) {
-        cells.push({ day, hour, value: 0 });
+}
+var AdapterRegistry = class {
+  methods = /* @__PURE__ */ new Map();
+  register(adapter, method, entry) {
+    this.methods.set(`${adapter}.${method}`, entry);
+  }
+  get(adapter, method) {
+    return this.methods.get(`${adapter}.${method}`);
+  }
+  has(adapter, method) {
+    return this.methods.has(`${adapter}.${method}`);
+  }
+};
+var AdapterCallRequestSchema = z.object({
+  requestId: z.string(),
+  adapter: AdapterNameSchema,
+  method: z.string(),
+  args: z.array(z.unknown()),
+  context: z.object({
+    namespaceId: z.string(),
+    hostId: z.string(),
+    workspaceId: z.string().optional(),
+    environmentId: z.string().optional(),
+    executionRequestId: z.string().optional(),
+    userId: z.string().optional(),
+    sessionId: z.string().optional()
+  })
+});
+function createAdapterRegistry() {
+  const registry = new AdapterRegistry();
+  registry.register("llm", "complete", {
+    inputSchema: z.array(z.unknown()),
+    outputSchema: z.unknown(),
+    execute: async (args) => {
+      const llm = platform.getAdapter("llm");
+      if (!llm) {
+        throw new Error("LLM adapter not available");
+      }
+      return llm.complete(...args);
+    }
+  });
+  registry.register("cache", "get", {
+    inputSchema: z.array(z.unknown()),
+    outputSchema: z.unknown().nullable(),
+    execute: async (args) => platform.cache.get(args[0])
+  });
+  registry.register("cache", "set", {
+    inputSchema: z.array(z.unknown()),
+    outputSchema: z.void(),
+    execute: async (args) => platform.cache.set(args[0], args[1], args[2])
+  });
+  registry.register("cache", "delete", {
+    inputSchema: z.array(z.unknown()),
+    outputSchema: z.void(),
+    execute: async (args) => platform.cache.delete(args[0])
+  });
+  registry.register("vectorStore", "search", {
+    inputSchema: z.array(z.unknown()),
+    outputSchema: z.unknown(),
+    execute: async (args) => {
+      const vs = platform.getAdapter("vectorStore");
+      if (!vs) {
+        throw new Error("VectorStore adapter not available");
       }
+      return vs.search(...args);
     }
-    return cells;
-  }
-  /**
-   * Fill gaps in heatmap data (missing day/hour combinations)
-   */
-  fillHeatmapGaps(cells) {
-    const days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
-    const cellMap = /* @__PURE__ */ new Map();
-    for (const cell of cells) {
-      const key = `${cell.day}:${cell.hour}`;
-      cellMap.set(key, cell.value);
-    }
-    const complete = [];
-    for (const day of days) {
-      for (let hour = 0; hour < 24; hour++) {
-        const key = `${day}:${hour}`;
-        complete.push({
-          day,
-          hour,
-          value: cellMap.get(key) ?? 0
-        });
+  });
+  registry.register("embeddings", "embed", {
+    inputSchema: z.array(z.unknown()),
+    outputSchema: z.unknown(),
+    execute: async (args) => {
+      const emb = platform.getAdapter("embeddings");
+      if (!emb) {
+        throw new Error("Embeddings adapter not available");
       }
+      return emb.embed(...args);
     }
-    return complete;
-  }
-  /**
-   * Aggregate data points by interval
-   */
-  aggregateByInterval(dataPoints, interval) {
-    if (dataPoints.length === 0) {
-      return [];
+  });
+  registry.register("storage", "read", {
+    inputSchema: z.array(z.unknown()),
+    outputSchema: z.unknown(),
+    execute: async (args) => {
+      const storage = platform.getAdapter("storage");
+      if (!storage) {
+        throw new Error("Storage adapter not available");
+      }
+      return storage.read(...args);
     }
-    const intervalMs = interval === "1m" ? 60 * 1e3 : 5 * 60 * 1e3;
-    const aggregated = [];
-    let bucket = [];
-    let bucketStart = Math.floor(dataPoints[0].timestamp / intervalMs) * intervalMs;
-    for (const point of dataPoints) {
-      const pointBucket = Math.floor(point.timestamp / intervalMs) * intervalMs;
-      if (pointBucket === bucketStart) {
-        bucket.push(point);
-      } else {
-        if (bucket.length > 0) {
-          const avgValue = bucket.reduce((sum, p) => sum + p.value, 0) / bucket.length;
-          aggregated.push({
-            timestamp: bucketStart + intervalMs / 2,
-            // midpoint
-            value: avgValue
-          });
-        }
-        bucket = [point];
-        bucketStart = pointBucket;
+  });
+  registry.register("storage", "write", {
+    inputSchema: z.array(z.unknown()),
+    outputSchema: z.void(),
+    execute: async (args) => {
+      const storage = platform.getAdapter("storage");
+      if (!storage) {
+        throw new Error("Storage adapter not available");
       }
+      return storage.write(...args);
     }
-    if (bucket.length > 0) {
-      const avgValue = bucket.reduce((sum, p) => sum + p.value, 0) / bucket.length;
-      aggregated.push({
-        timestamp: bucketStart + intervalMs / 2,
-        value: avgValue
-      });
+  });
+  return registry;
+}
+async function registerAdapterCallRoutes(server) {
+  const registry = createAdapterRegistry();
+  const internalSecret = process.env.GATEWAY_INTERNAL_SECRET;
+  const logger = platform.logger.child({ layer: "rest", route: "adapter-call" });
+  server.post("/api/v1/internal/adapter-call", async (request, reply) => {
+    const provided = request.headers["x-internal-secret"];
+    if (!internalSecret || provided !== internalSecret) {
+      return reply.code(403).send({ ok: false, error: { code: "FORBIDDEN", message: "Invalid internal secret", retryable: false } });
     }
-    return aggregated;
-  }
-  /**
-   * Get collector statistics
-   */
-  async getStats() {
-    const stats = {
-      running: this.intervalHandle !== null,
-      uptimeSeconds: (Date.now() - this.startTimeMs) / 1e3,
-      timeSeries: {},
-      heatmap: { cells: 0, metrics: [] }
-    };
-    for (const range of ["1m", "5m", "10m", "30m", "1h"]) {
-      const key = `metrics:history:${range}`;
-      const timeSeries = await this.cache.get(key);
-      if (timeSeries && Array.isArray(timeSeries)) {
-        stats.timeSeries[range] = {
-          points: timeSeries.length,
-          oldestTimestamp: timeSeries[0]?.timestamp ?? null,
-          newestTimestamp: timeSeries[timeSeries.length - 1]?.timestamp ?? null
-        };
-      } else {
-        stats.timeSeries[range] = { points: 0, oldestTimestamp: null, newestTimestamp: null };
-      }
+    const parsed = AdapterCallRequestSchema.safeParse(request.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ ok: false, error: { code: "VALIDATION_ERROR", message: parsed.error.message, retryable: false } });
     }
-    const heatmapData = await this.cache.get("metrics:heatmap:7d");
-    if (heatmapData && typeof heatmapData === "object") {
-      const metrics = Object.keys(heatmapData);
-      const totalCells = metrics.reduce((sum, m) => sum + (heatmapData[m]?.length ?? 0), 0);
-      stats.heatmap = { cells: totalCells, metrics };
+    const { requestId, adapter, method, args, context } = parsed.data;
+    const startMs = Date.now();
+    const entry = registry.get(adapter, method);
+    if (!entry) {
+      logger.warn("Adapter call rejected", { requestId, adapter, method, hostId: context.hostId });
+      return reply.code(403).send({ ok: false, error: { code: "ADAPTER_CALL_REJECTED", message: `Method not allowed: ${adapter}.${method}`, retryable: false } });
     }
-    return stats;
-  }
-  log(level, message, meta) {
-    if (level === "debug" && !this.config.debug) {
-      return;
+    try {
+      const operation = `adapter.call.${adapter}.${method}`;
+      const result = await restDomainOperationMetrics.observeOperation(
+        operation,
+        async () => entry.execute(args, context)
+      );
+      const latencyMs = Date.now() - startMs;
+      logger.info("Adapter call success", { requestId, adapter, method, hostId: context.hostId, latencyMs });
+      return { ok: true, result };
+    } catch (err) {
+      const latencyMs = Date.now() - startMs;
+      const message = err instanceof Error ? err.message : String(err);
+      logger.error("Adapter call failed", err instanceof Error ? err : void 0, { requestId, adapter, method, hostId: context.hostId, latencyMs });
+      return reply.code(500).send({
+        ok: false,
+        error: { code: "ADAPTER_ERROR", message, retryable: false }
+      });
     }
-    if (this.logger[level]) {
-      this.logger[level](`[HistoricalMetrics] ${message}`, meta);
-    } else {
-      console.log(`[HistoricalMetrics] [${level}] ${message}`, meta);
+  });
+}
+
+// src/routes/debug.ts
+var collectedRoutes = [];
+var seenRoutes = /* @__PURE__ */ new Set();
+function collectRoute(routeOptions) {
+  const methods = Array.isArray(routeOptions.method) ? routeOptions.method : [routeOptions.method];
+  for (const method of methods) {
+    if (method === "HEAD") {
+      continue;
+    }
+    const url = routeOptions.url;
+    const key = `${method}:${url}`;
+    if (!seenRoutes.has(key)) {
+      seenRoutes.add(key);
+      collectedRoutes.push({ method, url });
     }
   }
-};
+}
+function registerRouteCollector(fastify) {
+  fastify.addHook("onRoute", collectRoute);
+}
+async function registerDebugRoutes(fastify, config) {
+  const basePath = normalizeBasePath(config.basePath);
+  const routesPaths = resolvePaths(basePath, "/routes");
+  for (const path3 of routesPaths) {
+    fastify.get(path3, async (_request, reply) => {
+      let routes = collectedRoutes.filter((r) => r.url.startsWith("/api/"));
+      if (routes.length === 0) {
+        routes = [...collectedRoutes];
+      }
+      routes.sort((a, b) => {
+        const urlCompare = a.url.localeCompare(b.url);
+        if (urlCompare !== 0) {
+          return urlCompare;
+        }
+        return a.method.localeCompare(b.method);
+      });
+      let raw = null;
+      try {
+        raw = fastify.printRoutes({ commonPrefix: false });
+      } catch {
+      }
+      return reply.send({
+        schema: "kb.routes/1",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        count: routes.length,
+        routes,
+        raw
+      });
+    });
+  }
+}
 
 // src/routes/index.ts
 function normalizeBasePath2(basePath) {
@@ -5908,6 +5962,10 @@ async function registerPlugins(server, config) {
     const rateLimitOpts = {
       max: config.rateLimit.max,
       timeWindow: config.rateLimit.timeWindow,
+      allowList: (req) => {
+        const url = (req.url ?? "").split("?")[0] ?? "";
+        return url === "/health" || url === "/api/v1/health" || url === "/api/v1/ready" || url === "/api/v1/observability/health" || url === "/api/v1/studio/registry" || url === "/api/v1/logs/stream" || url.startsWith("/plugins/");
+      },
       addHeaders: {
         "x-ratelimit-limit": true,
         "x-ratelimit-remaining": true,
@@ -5925,6 +5983,9 @@ async function registerPlugins(server, config) {
     ui: corsProfile !== "prod"
   });
 }
+function isPluginErrorEnvelope(err) {
+  return err !== null && typeof err === "object" && "status" in err && err.status === "error" && "meta" in err && typeof err.meta === "object" && "pluginId" in err.meta;
+}
 function registerEnvelopeMiddleware(server, config) {
   server.addHook("onSend", async (request, reply, payload) => {
     try {
@@ -5937,7 +5998,14 @@ function registerEnvelopeMiddleware(server, config) {
       return payload;
     }
     if (typeof payload !== "string") {
-      return payload;
+      if (payload === null || payload === void 0 || Buffer.isBuffer(payload) || typeof payload.pipe === "function" || typeof payload.getReader === "function") {
+        return payload;
+      }
+      try {
+        return JSON.stringify(payload);
+      } catch {
+        return payload;
+      }
     }
     let parsedPayload;
     try {
@@ -5975,36 +6043,51 @@ function registerEnvelopeMiddleware(server, config) {
     return JSON.stringify(envelope);
   });
   server.setErrorHandler(async (error, request, reply) => {
-    const statusCode = error.statusCode || 500;
-    const errorCode = error.code || "E_INTERNAL";
-    const message = error.message || "Internal server error";
-    const details = error.details || {};
-    const cause = error.cause;
-    const traceId = error.traceId;
+    let statusCode;
+    let errorCode;
+    let message;
+    let details;
+    let cause;
+    let traceId;
+    if (isPluginErrorEnvelope(error)) {
+      statusCode = error.http || 500;
+      errorCode = error.code || "E_PLUGIN";
+      message = error.message || "Plugin error";
+      details = {
+        ...error.details ?? {},
+        pluginId: error.meta.pluginId,
+        pluginVersion: error.meta.pluginVersion,
+        routeOrCommand: error.meta.routeOrCommand,
+        ...error.trace ? { trace: error.trace } : {}
+      };
+      cause = void 0;
+      traceId = void 0;
+    } else {
+      const err = error;
+      statusCode = err.statusCode || 500;
+      errorCode = err.code || "E_INTERNAL";
+      message = err.message || "Internal server error";
+      details = err.details || {};
+      cause = err.cause;
+      traceId = err.traceId;
+    }
     reply.errorCode = errorCode;
     if (request.kbLogger) {
-      request.kbLogger.error("Request error", error, {
+      request.kbLogger.error("Request error", error instanceof Error ? error : new Error(String(error)), {
         errorCode,
         statusCode
       });
     }
     const errorEnvelope = errorEnvelopeSchema.parse({
       ok: false,
-      error: {
-        code: errorCode,
-        message,
-        details,
-        cause,
-        traceId
-      },
+      error: { code: errorCode, message, details, cause, traceId },
       meta: {
         requestId: request.id,
         durationMs: reply.elapsedTime || 0,
         apiVersion: config.apiVersion
       }
     });
-    reply.status(statusCode);
-    return errorEnvelope;
+    reply.status(statusCode).send(errorEnvelope);
   });
 }
 function registerRequestIdMiddleware(server) {
@@ -6096,46 +6179,18 @@ function registerCacheMiddleware(server) {
     return payload;
   });
 }
-function registerErrorGuard(server) {
-  server.setErrorHandler((error, request, reply) => {
-    if (error && typeof error === "object" && "status" in error && error.status === "error" && "meta" in error && error.meta && typeof error.meta === "object" && "pluginId" in error.meta) {
-      const envelope2 = error;
-      reply.status(envelope2.http).send(envelope2);
-      return;
-    }
-    const requestId = request.id || "unknown";
-    const err = error instanceof Error ? error : new Error(String(error));
-    const errWithStatus = error;
-    const envelope = {
-      status: "error",
-      http: errWithStatus.statusCode || 500,
-      code: ErrorCode.INTERNAL,
-      message: err.message || "Internal server error",
-      details: {
-        error: err.message || String(error)
-      },
-      trace: err.stack,
-      meta: {
-        requestId,
-        pluginId: "system",
-        pluginVersion: "unknown",
-        routeOrCommand: request.url || "unknown",
-        timeMs: 0
-      }
-    };
-    reply.status(envelope.http).send(envelope);
-  });
+function registerProcessErrorGuard(server) {
   process.on("uncaughtException", (error) => {
-    platform.logger.fatal("Uncaught exception", error, { source: "error-guard" });
+    platform.logger.fatal("Uncaught exception", error, { source: "process-error-guard" });
   });
   process.on("unhandledRejection", (reason) => {
     const error = reason instanceof Error ? reason : new Error(String(reason));
-    platform.logger.error("Unhandled rejection", error, { source: "error-guard" });
+    platform.logger.error("Unhandled rejection", error, { source: "process-error-guard" });
   });
 }
 
-// src/middleware/startup-guard.ts
-function registerStartupGuard(server, config) {
+// src/middleware/startup-throttle.ts
+function registerStartupThrottle(server, config) {
   const startupConfig = config.startup;
   if (!startupConfig) {
     return;
@@ -6242,8 +6297,6 @@ function registerRequestTimeoutGuard(server, config) {
     done();
   });
 }
-
-// src/middleware/rate-limit.ts
 function extractTenantId(request) {
   return request.headers["x-tenant-id"] || process.env.KB_TENANT_ID || "default";
 }
@@ -6268,8 +6321,6 @@ function createRateLimitMiddleware(rateLimiter) {
     request.tenantId = tenantId;
   };
 }
-
-// src/middleware/tenant-rate-limit.ts
 function registerTenantRateLimitMiddleware(server, cache) {
   const limiter = new TenantRateLimiter(cache);
   limiter.setTier("default", getDefaultTenantTier());
@@ -6279,16 +6330,16 @@ function registerTenantRateLimitMiddleware(server, cache) {
 
 // src/middleware/index.ts
 function registerMiddleware(server, config) {
-  registerStartupGuard(server, config);
+  registerStartupThrottle(server, config);
   registerSecurityHeadersMiddleware(server);
   registerRequestIdMiddleware(server);
   registerTenantRateLimitMiddleware(server, platform.cache);
   registerMockModeMiddleware(server, config);
-  registerCacheMiddleware(server);
   registerRequestTimeoutGuard(server, config);
   registerMetricsMiddleware(server);
   registerEnvelopeMiddleware(server, config);
-  registerErrorGuard(server);
+  registerCacheMiddleware(server);
+  registerProcessErrorGuard();
 }
 var kDisableRequestLogging = /* @__PURE__ */ Symbol.for("fastify.disableRequestLogging");
 async function createServer(config, repoRoot, registry) {
@@ -6375,72 +6426,25 @@ async function createServer(config, repoRoot, registry) {
 var registryInstance = null;
 var metricsCollector2 = null;
 async function findMonorepoRoot(startDir) {
-  let dir = path2.resolve(startDir);
-  let monorepoRoot = null;
-  while (true) {
-    try {
-      const workspacePath = path2.join(dir, "pnpm-workspace.yaml");
-      await promises.access(workspacePath);
-      const content = await promises.readFile(workspacePath, "utf-8");
-      if (content.includes("kb-*")) {
-        monorepoRoot = dir;
-        break;
-      }
-    } catch {
-    }
-    const parent = path2.dirname(dir);
-    if (parent === dir) {
-      break;
-    }
-    dir = parent;
-  }
-  if (monorepoRoot) {
-    return monorepoRoot;
-  }
-  dir = path2.resolve(startDir);
-  let foundRoot = null;
-  while (true) {
-    try {
-      const hasGit = await promises.access(path2.join(dir, ".git")).then(() => true).catch(() => false);
-      const hasWorkspace = await promises.access(path2.join(dir, "pnpm-workspace.yaml")).then(() => true).catch(() => false);
-      if (hasGit && hasWorkspace) {
-        foundRoot = dir;
-      }
-    } catch {
-    }
-    const parent = path2.dirname(dir);
-    if (parent === dir) {
-      break;
-    }
-    dir = parent;
-  }
-  if (foundRoot) {
-    return foundRoot;
-  }
-  dir = path2.resolve(startDir);
-  let topmostWorkspace = null;
+  let dir = path.resolve(startDir);
   while (true) {
-    try {
-      await promises.access(path2.join(dir, "pnpm-workspace.yaml"));
-      topmostWorkspace = dir;
-    } catch {
+    const hasWorkspace = await promises.access(path.join(dir, "pnpm-workspace.yaml")).then(() => true).catch(() => false);
+    if (hasWorkspace) {
+      return dir;
     }
-    const parent = path2.dirname(dir);
+    const parent = path.dirname(dir);
     if (parent === dir) {
       break;
     }
     dir = parent;
   }
-  if (topmostWorkspace) {
-    return topmostWorkspace;
-  }
   return findRepoRoot(startDir);
 }
 async function bootstrap(cwd = process.cwd()) {
   const repoRoot = await findMonorepoRoot(cwd);
   loadEnvFromRoot(repoRoot);
   const { config, diagnostics } = await loadRestApiConfig(cwd);
-  await createServiceBootstrap({ appId: "rest-api", repoRoot });
+  await createServiceBootstrap({ appId: "rest-api", repoRoot, assemblyHook: makeAssemblyHook() });
   const startupRequestId = `rest-startup-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
   const startupTraceId = randomUUID();
   const startupSpanId = randomUUID();
@@ -6468,10 +6472,11 @@ async function bootstrap(cwd = process.cwd()) {
   bootstrapLogger.info("Initializing entity registry");
   const isDevelopment = process.env.NODE_ENV !== "production";
   const snapshotTTL = isDevelopment ? 10 * 60 * 1e3 : 60 * 60 * 1e3;
-  const registryRoot = getPlatformRoot() ?? repoRoot;
+  const platformRoot = getPlatformRoot();
   const registryInitStart = performance.now();
   const registry = await createRegistry({
-    root: registryRoot,
+    root: repoRoot,
+    platformRoot: platformRoot !== repoRoot ? platformRoot : void 0,
     cache: {
       ttlMs: snapshotTTL,
       adapter: platform.cache
@@ -6496,10 +6501,12 @@ async function bootstrap(cwd = process.cwd()) {
   bootstrapLogger.info("Starting system metrics collector");
   metricsCollector2 = new SystemMetricsCollector("rest", () => metricsCollector.getActiveRequests());
   await metricsCollector2.start(1e4, 6e4);
-  const address = await server.listen({
-    port: config.port,
-    host: process.env.REST_API_HOST ?? "0.0.0.0"
-  });
+  const restTransport = platform.getAdapter("serviceTransport");
+  const restAddr = restTransport?.listenAddress?.("rest");
+  const listenPort = restAddr && "port" in restAddr ? restAddr.port : config.port;
+  const restAddrHost = restAddr && "host" in restAddr ? restAddr.host : void 0;
+  const restHost = process.env.REST_API_HOST ?? restAddrHost ?? "0.0.0.0";
+  const address = await server.listen(getListenOptions(listenPort, restHost));
   bootstrapLogger.info("REST API server listening", { address });
   const shutdown = async (signal) => {
     bootstrapLogger.warn("Received shutdown signal", { signal });